Django 接口自动化测试平台

本项目工程 github 地址：https://github.com/juno3550/InterfaceAutoTestPlatform

0. 引言

1. 登录功能

2. 项目

3. 模块

4. 测试用例

5. 用例集合

6. 用例集合添加测试用例

7. 用例集合查看/删除测试用例

8. 测试用例执行

9. 用例执行结果展示

10. 测试集合执行

11. 用例集合执行结果展示

12. 用例集合历史执行结果统计

13. 用例集合单次执行结果统计

14. 模块测试结果统计

15. 项目测试结果统计

16. Celery 异步执行用例 

 

 

0. 引言

0.1 平台功能概述

本接口自动化测试平台的整体功能如下图所示：

0.2 创建项目与应用

本项目环境如下：

• python 3.6.5
• pip install django==2.2.4
• pip install redis==2.10.6
• pip install eventlet==0.25.2
• pip install celery==3.1.26.post2

对于 Django 的基础使用教程，可以参考本博客的《Django》系列博文。

1）创建本项目工程

# 方式一
django-admin startproject InterfaceAutoTest

# 方式二
python -m django startproject interface_test_platform

此时工程结构如下所示：

2）创建应用

在项目目录下，使用如下命令创建应用：

django-admin startapp interfacetestplatform

此时工程结构目录如下：

3）注册应用

在项目目录 InterfaceAutoTest/settings.py 中，找到 INSTALLED_APPS 配置项，在列表末尾添加新建的应用名称“interfacetestplatform”：

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'interfacetestplatform,'
]

新建的应用需要在 INSTALLED_APPS 配置项中注册，Django 会根据该配置项到应用下查找模板等信息。

4）使用 Bootstrap

Bootstrap 是流行的 HTML、CSS 和 JS 框架，用于开发响应式布局、移动设备优先的 Web 项目。

• 下载 bootstrap：https://v3.bootcss.com/getting-started/#download
• 下载 jquery：https://jquery.com/download/

在项目目录下新建一个 static 目录，将解压后的如 bootstrap-3.3.7-dist 目录整体拷贝到 static 目录中，并将文件名改为 bootstrap。

由于 bootstrap 依赖 jQuery，我们需要提前下载并引入 jQuery。在 static 目录下，新建 css 和 js 目录，作为后面的样式文件和 js 文件的存放地，将我们的 jQuery 文件拷贝到 static/js/ 目录下。

ECharts 是一个使用 JavaScript 实现的开源可视化库，在本项目中用于用例/集合的执行结果统计可视化。于是我们引入 echarts 文件到 static/js/ 目录下。

此时 static 目录结构如下图所示：

在项目目录下的 settings.py 文件的末尾添加如下配置，用于指定静态文件的搜索目录：

STATICFILES_DIRS = [
    os.path.join(BASE_DIR, "static"),
]

通过 STATICFILES_DIRS 属性，可以指定静态资源的路径，此处配置的是项目根目录下的 static 文件夹下。

默认情况下，Django 只能识别项目应用目录下的 static 目录的静态资源，不会识别到项目目录下的 static目录，因此通过 STATICFILES_DIR 属性可以解决这个问题。

5）创建应用的模板目录 

在应用目录下新建一个 templates 目录，专门存放本应用所有的模板文件。

默认情况下，Django 只能识别项目应用目录下的 templates 目录的静态资源。本工程因仅涉及一个应用，因此选用此方案。

若应用较多，为了易于维护，可将各应用的模板文件进行统一处理，则在项目目录下新建 templates 目录，并在 settings.py 中新增配置：

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

6）启动 Django 的 Web 服务

在项目目录下，运行如下命令启动端口号为 8000 的 Django 的 Web 服务： 

python manage.py runsever 8000  # 端口号可自定义，不写则默认8000

启动日志如下：

You have 18 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.
July 13, 2021 - 10:03:23
Django version 3.2.5, using settings 'InterfaceAutoTest.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.

启动成功后，用浏览器访问 127.0.0.1:8000，可以看到 Django 默认的页面，如下所示即代表服务启动成功：

7）配置 Mysql 数据库

修改项目目录下的 settings.py 文件，将 DATABASES 配置项改为如下配置：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'interface_platform',  # 已存在的库名
         'USER': 'root',  # 数据库账号
         'PASSWORD': '123',  # 数据库密码
         'HOST': '127.0.0.1',  # 数据库IP
        'PORT': '3306',  # 数据库端口
    }
}

若使用的是 Python 3 的 pymysql，则需要在项目的 __init__.py 文件中添加如下内容，避免报错：

import pymysql
pymysql.version_info = (1, 4, 13, "final", 0)  # 指定版本。在出现“mysqlclient 1.4.0 or newer is required; you have 0.9.3.”报错时加上此行
pymysql.install_as_MySQLdb()

8）创建 Admin 站点超级用户

首先在项目目录下进行数据迁移，生成 auth_user 等基础表：

python manage.py migrate

在工程目录下，执行以下命令创建超级用户，用于登录 Django 的 Admin 站点：

D:\InterfaceAutoTest>python manage.py createsuperuser
Username (leave blank to use 'administrator'): admin  # 用户名
Email address: admin@123.com  # 符合邮箱格式即可
Password:    # 密码
Password (again):    # 二次确认密码
The password is too similar to the username.
This password is too common.
Bypass password validation and create user anyway? [y/N]: y
Superuser created successfully.

创建好 superuser 后，访问 127.0.0.1:8000/admin，用注册的 admin 账户进行登录（数据参考的就是 auth_user 表，并且必须是管理员用户才能进入）。

配置 admin 语言和时区

登录 admin 页面，可以看到页面的标题、菜单显示的语言是英文，那么如何展示为中文呢？

在 settings.py 中，找到 MIDDLEWARE 属性，添加中间件。

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.locale.LocaleMiddleware', 
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

 

同时，在后续添加项目信息表数据时，可以发现数据的创建时间、更新时间字段的时间不是本地时间，而是 UTC 时间，那么怎么展示为国内本地时间呢？

也是 settings.py 中，修改 TIME_ZONE 和 USE_TZ 的配置项：

TIME_ZONE = 'Asia/Shanghai'

USE_TZ = False

这样配置后，admin 页面中数据表的时间字段以及前端模板中的时间字段都是本地时区的时间。

• 当 USE_TZ 为 False 时，TIME_ZONE值是 Django 存储所有日期时间的时区。
• 当 USE_TZ 为 True 时，TIME_ZONE值是 Django 在模板中显示日期时间和解释表单中输入的日期时间的默认时区。简单起见，USE_TZ 直接设为 False。

  

1. 登录功能

预期效果如下：

1.1 定义路由

1） 路由定义规则说明

路由的基本信息包含路由地址和视图函数，路由地址即访问网址，视图函数即客户端在访问指定网址后，服务器端所对应的处理逻辑。

在应用目录（interfacetestplatform 目录）下新建 urls.py，将所有属于该应用的路由都写入该文件中，这样更容易管理和区分每个应用的路由地址，而项目目录（InterfaceAutoTest）下的 urls.py 是将每个应用的 urls.py 进行统一管理。

这种路由设计模式是 Django 常用的，其工作原理如下：

1. 运行 InterfaceAutoTest 项目时，Django 从 interfacetestplatform （应用）目录的 urls.py 找到对应应用所定义的路由信息，生成完整的路由表。
2. 当用户在浏览器上访问某个路由地址时，Django 服务端就会收到该用户的请求信息。Django 从当前请求信息获取路由地址，首先匹配项目目录下的 urls.py 的路由列表。转发到指定应用的 urls.py 的路由列表。
3. 再执行应用下的路由信息所指向的视图函数，从而完成整个请求响应过程。

2）路由配置

配置项目 urls.py：InterfaceAutoTest/urls.py

from django.contrib import admin
from django.urls import path, include


urlpatterns = [
    path('admin/', admin.site.urls),  # 指向内置Admin后台系统的路由文件sites.py
    path('', include('interfacetestplatform.urls')),  # 指向interfacetestplatform应用的urls.py
    ]

由于默认地址分发给了 interfacetestplatform（应用）的 urls.py 进行处理，因此需要对 interfacetestplatform/urls.py 编写路由信息，代码如下：

from django.urls import path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
]

如路由信息 path('', views.index) 的 views.index 是指专门处理网站默认页的用户请求和响应过程的视图函数名称 index，其他路由规则原理一样。

1.2 定义视图函数

1）定义 Form 表单类

在定义视图函数之前，我们先定义 Django 提供的表单模型类，来代替原生的前端 Form 表单。

在应用目录下，新建 form.py：

from django import forms


class UserForm(forms.Form):
    username = forms.CharField(label="用户名", max_length=128, widget=forms.TextInput(attrs={'class': 'form-control'}))
    password = forms.CharField(label="密码", max_length=256, widget=forms.PasswordInput(attrs={'class': 'form-control'}))

2）定义视图函数

在应用的 interfacepestplatform/views.py （视图模块）中添加如下代码：

from django.shortcuts import render, redirect
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from .form import UserForm
import traceback


# Create your views here.
# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配成功则返回用户对象；反之返回None
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

render 方法

用来生成网页内容并返回给客户端，其两个必须参数表示：第一个参数是浏览器想服务器发送的请求对象；第二个参数是模板名称，用于生成网页内容。

auth 模块

auth 模块是 cookie 和 session 的升级版。

auth 模块是对登录认证方法的一种封装，之前我们获取用户输入的用户名及密码后需要自己从 user 表里查询有没有用户名和密码符合的对象，而有了 auth 模块之后就可以很轻松地去验证用户的登录信息是否存在于数据库（auth_user 表）中。

除此之外，auth 还对 session 做了一些封装，方便我们校验用户是否已登录。

login 方法

对于非 POST 方法的请求（如 GET 请求），直接返回空的表单，让用户可以填入数据。

对于 POST 方法请求，接收表单数据，并验证：

1. 使用表单类自带的 is_valid() 方法进一步完成数据验证工作；
2. 验证成功后可以从表单对象的 cleand_data 数据字典中获取表单的具体值；
3. 如果验证不通过，则返回一个包含先前数据的表单给前端页面，方便用户修改。也就是说，它会帮你保留先前填写的数据内容，而不是返回一个空表。
4. 另外，这里使用了一个小技巧，python 内置了一个 locals() 函数，它返回当前所有的本地变量字典，我们可以偷懒的将这作为 render 函数的数据字典参数值，就不用费劲去构造一个形如 {'message':message, 'login_form':login_form} 的字典了。这样做的好处是大大方便了我们；但同时也可能往模板传入一些多余的变量数据，造成数据冗余降低效率。

@login_required

为函数增加装饰器 @login_required，这种方式可以实现未登录禁止访问首页的功能。

此种方式需要在项目 settings.py 中添加如下配置：

LOGIN_URL = '/login/'

通过 LOGIN_URL 告诉 Django 在用户没登录的情况下，重定向的登录地址；如果没配置该属性，Django 会重定向到默认地址。 

如果不用装饰器方式，也可以在函数内部判断用户状态，并实现重定向。如下所示，效果是一样的：

def index(request):
    print("request.user.is_authenticated: {}".format(request.user.is_authenticated))
    if not request.user.is_authenticated:
        return redirect("/login/")
    return render(request,'index.html')

1.3 定义模板文件

1）定义 base 基础模板，供其他模板继承

新建 interfacetestplatform/templates/base.html，用作平台前端的基础模板，代码如下：

<!DOCTYPE html>
<html lang="zh-CN">
{% load static %}
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
    <title>{% block title %}base{% endblock %}</title>

    <!-- Bootstrap -->
    <link href="{% static 'bootstrap/css/bootstrap.min.css' %}" rel="stylesheet">

    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    <script src="https://cdn.bootcss.com/html5shiv/3.7.3/html5shiv.min.js"></script>
    <script src="https://cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
    {% block css %}{% endblock %}
</head>
<body>
<nav class="navbar navbar-default">
    <div class="container-fluid">
        <!-- Brand and toggle get grouped for better mobile display -->
        <div class="navbar-header">
            <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#my-nav"
                    aria-expanded="false">
                <span class="sr-only">切换导航条</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>
            <a class="navbar-brand" href="#">自动化测试平台</a>
        </div>

        <div class="collapse navbar-collapse" id="my-nav">
            <ul class="nav navbar-nav">
                <li class="active"><a href="/">主页</a></li>
            </ul>
            <ul class="nav navbar-nav navbar-right">
                {% if request.user.is_authenticated %}
                <li><a href="#">当前在线：{{ request.user.username }}</a></li>
                <li><a href="/logout">登出</a></li>
                {% else %}
                <li><a href="/login">登录</a></li>

                {% endif %}
            </ul>
        </div><!-- /.navbar-collapse -->
    </div><!-- /.container-fluid -->
</nav>

{% block content %}{% endblock %}


<!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
<script src="{% static 'js/jquery-3.4.1.js' %}"></script>
<!-- Include all compiled plugins (below), or include individual files as needed -->
<script src="{% static 'bootstrap/js/bootstrap.min.js' %}"></script>
</body>
</html>

在 base 模板中，通过 if 判断，当登录成功时，显示当前用户名和登出按钮；未登录时，则显示登录按钮。

注意，request 这个变量是默认被传入模板中的，可以通过圆点的调用方式获取对象中的属性，如 {{ reques.user.username }} 表示当前登录的用户名。

2）定义 login 登录模板

首先在 static/css/ 目录中，新建一个 login.css 样式文件，配置一些简单样式：

body {
  background-color: #eee;
}
.form-login {
  max-width: 330px;
  padding: 15px;
  margin: 0 auto;
}
.form-login .form-control {
  position: relative;
  height: auto;
  -webkit-box-sizing: border-box;
     -moz-box-sizing: border-box;
          box-sizing: border-box;
  padding: 10px;
  font-size: 16px;
}
.form-login .form-control:focus {
  z-index: 2;
}
.form-login input[type="text"] {
  margin-bottom: -1px;
  border-bottom-right-radius: 0;
  border-bottom-left-radius: 0;
}
.form-login input[type="password"] {
  margin-bottom: 10px;
  border-top-left-radius: 0;
  border-top-right-radius: 0;
}

然后新建 templates/login.html：

{% extends 'base.html' %}
{% load static %}
{% block title %}登录{% endblock %}
{% block css %}
<link rel="stylesheet" href="{% static 'css/login.css' %}">
{% endblock %}

{% block content %}
<div class="container">
    <div class="col-md-4 col-md-offset-4">
        <form class='form-login' action="/login/" method="post">
            {% csrf_token %}

            <!-- 如果有登录信息，则提示 -->
            {% if message %}
                <div class="alert alert-warning">{{ message }}</div>
            {% endif %}

            <h2 class="text-center">欢迎登录</h2>

            <div class="form-group">
                {{ login_form.username.label_tag }}
                {{ login_form.username}}
            </div>
            <div class="form-group">
                {{ login_form.password.label_tag }}
                {{ login_form.password }}
            </div>

            <button type="reset" class="btn btn-default pull-left">重置</button>
            <button type="submit" class="btn btn-primary pull-right">提交</button>
        </form>
    </div>
</div> <!-- /container -->
{% endblock %}

login 模板说明：

• 通过 “{% extends 'base.html' %}” 继承了“base.html”模板的内容。
• 通过 “{% block title %} 登录 {% endblock %}” 设置了专门的 title。
• 若页面提示 CSRF 验证失败，我们需要在前端页面的 form 表单内添加一个 {% csrf_token %} 标签，CSRF（Cross-site request forgery）跨站请求伪造，是一种常见的网络攻击手段。为此，Django 自带了许多常见攻击手段的防御机制，CSRF 就是其中一种，还有防 XSS、SQL 注入等。
• 通过 “{% block css %}”引入了针对性的 login.css 样式文件。
• 主体内容定义在“{% block content %}”中。
• 使用 {{ login_form.name_of_field }} 方式分别获取每一个字段，然后分别进行渲染。

3）定义 index 首页模板

新增 templates/index.html：

{% extends 'base.html' %}
{% block title %}主页{% endblock %}
{% block content %}
    {% if request.user.is_authenticated %}
    <h1>你好，{{ request.user.username }}！欢迎回来！</h1>
    {% endif %}
{% endblock %}

根据登录状态的不同，显示不同的内容。

  

2. 项目

预期效果如下：

2.1 定义模型类

Django 的模型类提供以面向对象的方式管理数据库数据，即 ORM（关系对象映射）的思想。

1）编写模型类

打开应用目录下的 models.py，定义项目信息的模型类：

from django.db import models


class Project(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('项目名称', max_length=50, unique=True, null=False)
    proj_owner = models.CharField('项目负责人', max_length=20, null=False)
    test_owner = models.CharField('测试负责人', max_length=20, null=False)
    dev_owner = models.CharField('开发负责人', max_length=20, null=False)
    desc = models.CharField('项目描述', max_length=100, null=True)
    create_time = models.DateTimeField('项目创建时间', auto_now_add=True)
    update_time = models.DateTimeField('项目更新时间', auto_now=True, null=True)

    # 打印对象时返回项目名称
    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '项目信息表'
        verbose_name_plural = '项目信息表'

字段说明：

• name：项目名称，必填，最长不超过 128 个字符，并且唯一，也就是不能有相同项目名称。
• proj_owner：项目负责人，必填，最长不超过 20 个字符（实际可能不需要这么长）。
• test_owner：测试负责人。必填，最长不超过 20 个字符。
• dev_owner：开发负责人，必填，最长不超过 20 个字符。
• desc ：项目描述，选填，最长不超过 100 个字符。
• create_time：创建时间，必填，默认使用当前时间。
• update_time：更新时间，选填，默认为当前时间。
• 使用 __str__ 更友好地打印对象信息。
• Meta 类属性 verbose_name 指定了后台 Admin 页面展示的表名称。

2）数据迁移

在项目目录下，执行以下两个命令进行数据迁移（将模型类转换成数据库表）：

python manage.py makemigrations  # 生成迁移文件（模型类的信息）
python manage.py migrate  # 执行开始迁移（将模型类信息转换成数据库表）

从数据库迁移过程来看，迁移文件的内容是 Django 与 Mysql 之间的沟通语言，Django 通过 ORM（对象关系映射）功能，把模型类生成的迁移文件，映射到 Mysql 中，Mysql 通过迁移文件内容，创建对应的数据库表信息。

ORM 的好处就是，我们不需要编写 SQL 语句，而是通过 Django 的模型类，就可以在 Mysql 中创建和操作想要的表对象及其数据。

除了模型类中定义的表，初次执行迁移命令也会生成 Django 内置的表，这些表是服务于 Django 内置的功能。

2）Admin 站点增加项目数据

在应用目录下的 admin.py 中，添加如下代码：

from django.contrib import admin
from .import models


class ProjectAdmin(admin.ModelAdmin):
    list_display = ("id", "name", "proj_owner", "test_owner", "dev_owner", "desc", "create_time", "update_time")

admin.site.register(models.Project, ProjectAdmin)

admin.site.register() 方法把模型类 Project 和 ProjectAdmin 进行绑定，并注册到 Admin 系统。通过 ProjectAdmin 类中的 list_display 字段，定义了后台 Admin 页面展示 Project 表的字段列表。 

进入 Admin 页面并添加数据：

可以看到，在应用名称下展示了“项目信息表”，接着可以依次点击“项目信息表”—“ADD 项目信息表 +”—填写所需新增的项目信息—“SAVE”，完成项目信息的数据添加。

2.2 定义路由

添加项目管理页面的路由信息：

from django.urls import path
from . import views

urlpatterns = [
    path('',views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name="project"),
]

2.3 定义视图函数

from django.shortcuts import render, redirect
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from .form import UserForm
import traceback
from .models import Project


# 项目管理页的视图函数
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)  # 打印用户是否已登录
    projects = Project.objects.filter().order_by('-id')  # 使用负id是为了倒序取出项目数据
    print("projects:", projects)  # 打印项目名称
    return render(request, 'project.html', {'projects': projects})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

2.4 定义模板文件

1）新增 templates/project.html 模板，用于展示项目信息：

{% extends 'base.html' %}
{% load static %}
{% block title %}项目{% endblock %}

{% block content %}
    <div class="table-responsive">
        <table class="table table-striped">
            <thead>
                <tr>
                    <th>id</th>
                    <th>项目名称</th>
                    <th>项目负责人</th>
                    <th>测试负责人</th>
                    <th>开发负责人</th>
                    <th>简要描述</th>
                    <th>创建时间</th>
                    <th>更新时间</th>
                    <th>测试结果统计</th>
                </tr>
            </thead>
            <tbody>

            {% for project in projects %}
                <tr>
                    <td>{{ project.id }}</td>
                    <td>{{ project.name }}</td>
                    <td>{{ project.proj_owner }}</td>
                    <td>{{ project.test_owner }}</td>
                    <td>{{ project.dev_owner }}</td>
                    <td>{{ project.desc }}</td>
                    <td>{{ project.create_time|date:"Y-n-d H:i" }}</td>
                    <td>{{ project.update_time|date:"Y-n-d H:i" }}</td>
                    <td><a href=""> 查看</a></td>
                </tr>
            {% endfor %}
            </tbody>
        </table>
    </div>
{% endblock %}

2）调整 base.html 模板：导航栏增加项目菜单，把“主页”菜单改为“项目”，同时把“自动化测试平台”菜单连接调整为”/”，即首页页面。

<!DOCTYPE html>
<html lang="zh-CN">
{% load static %}
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
    <title>{% block title %}base{% endblock %}</title>

    <!-- Bootstrap -->
    <link href="{% static 'bootstrap/css/bootstrap.min.css' %}" rel="stylesheet">


    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    <script src="https://cdn.bootcss.com/html5shiv/3.7.3/html5shiv.min.js"></script>
    <script src="https://cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
    {% block css %}{% endblock %}
</head>
<body>
<nav class="navbar navbar-default">
    <div class="container-fluid">
        <!-- Brand and toggle get grouped for better mobile display -->
        <div class="navbar-header">
            <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#my-nav"
                    aria-expanded="false">
                <span class="sr-only">切换导航条</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>
            <a class="navbar-brand" href="/">自动化测试平台</a>
        </div>

        <div class="collapse navbar-collapse" id="my-nav">
            <ul class="nav navbar-nav">
                <li class="active"><a href="/project/">项目</a></li>
            </ul>
            <ul class="nav navbar-nav navbar-right">
                {% if request.user.is_authenticated %}
                <li><a href="#">当前在线：{{ request.user.username }}</a></li>
                <li><a href="/logout">登出</a></li>
                {% else %}
                <li><a href="/login">登录</a></li>

                {% endif %}
            </ul>
        </div><!-- /.navbar-collapse -->
    </div><!-- /.container-fluid -->
</nav>

{% block content %}{% endblock %}


<!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
<script src="{% static 'js/jquery-3.4.1.js' %}"></script>
<!-- Include all compiled plugins (below), or include individual files as needed -->
<script src="{% static 'bootstrap/js/bootstrap.min.js' %}"></script>
</body>
</html>

2.5 处理分页 

1）新增封装分页处理对象的视图函数：

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
from .models import Project


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

2）修改 project.html 模板，新增分页处理内容：

{% extends 'base.html' %}
{% load static %}
{% block title %}主页{% endblock %}

{% block content %}
<div class="table-responsive">
    <table class="table table-striped">
        <thead>
        <tr>
            <th>id</th>
            <th>项目名称</th>
            <th>项目负责人</th>
            <th>测试负责人</th>
            <th>开发负责人</th>
            <th>简要描述</th>
            <th>创建时间</th>
            <th>更新时间</th>
            <th>测试结果统计</th>
        </tr>
        </thead>
        <tbody>

        {% for project in projects %}
        <tr>
            <td>{{ project.id }}</td>
            <td>{{ project.name }}</td>
            <td>{{ project.proj_owner }}</td>
            <td>{{ project.test_owner }}</td>
            <td>{{ project.dev_owner }}</td>
            <td>{{ project.desc }}</td>
            <td>{{ project.create_time|date:"Y-n-d H:i" }}</td>
            <td>{{ project.update_time|date:"Y-n-d H:i" }}</td>
            <td><a href=""> 查看</a></td>
        </tr>
        {% endfor %}
        </tbody>
    </table>
</div>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if projects.has_previous %}
                <a class='active' href="?page={{ projects.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                        第 {{ projects.number }} 页 / 共 {{ projects.paginator.num_pages }} 页</span>

                {% if projects.has_next %}
                <a class='active' href="?page={{ projects.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

 

3. 模块

预期效果如下：

模块管理的实现思路与项目管理相似，我们依然遵循模型类 —> admin 增加数据 —> 路由 —> 视图函数 —> 模板文件的步骤来实现。

3.1 定义模型类 

1）应用的 models.py 中增加 Module 模型类：

from django.db import models


class Project(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('项目名称', max_length=50, unique=True, null=False)
    proj_owner = models.CharField('项目负责人', max_length=20, null=False)
    test_owner = models.CharField('测试负责人', max_length=20, null=False)
    dev_owner = models.CharField('开发负责人', max_length=20, null=False)
    desc = models.CharField('项目描述', max_length=100, null=True)
    create_time = models.DateTimeField('项目创建时间', auto_now_add=True)
    update_time = models.DateTimeField('项目更新时间', auto_now=True, null=True)

    # 打印时返回项目名称
    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '项目信息表'
        verbose_name_plural = '项目信息表'


class Module(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('模块名称', max_length=50, null=False)
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE)
    test_owner = models.CharField('测试负责人', max_length=50, null=False)
    desc = models.CharField('简要描述', max_length=100, null=True)
    create_time = models.DateTimeField('创建时间', auto_now_add=True)
    update_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '模块信息表'
        verbose_name_plural = '模块信息表'

2）数据迁移

在项目目录下，执行以下两个命令进行数据迁移（将模型类转换成数据库表）：

python manage.py makemigrations  # 生成迁移文件（模型类的信息）
python manage.py migrate  # 执行开始迁移（将模型类信息转换成数据库表）

3.2 后台 admin 添加数据

1）注册模型类到 admin：

from django.contrib import admin
from . import models


class ProjectAdmin(admin.ModelAdmin):
    list_display = ("id", "name", "proj_owner", "test_owner", "dev_owner", "desc", "create_time", "update_time")

admin.site.register(models.Project, ProjectAdmin)


class ModuleAdmin(admin.ModelAdmin):
    list_display = ("id", "name", "belong_project", "test_owner", "desc", "create_time", "update_time")

admin.site.register(models.Module, ModuleAdmin)

2）登录 admin 系统，添加模块数据

访问：http://127.0.0.1:8000/admin/，进入模块信息表，添加数据。

 

3.3 定义路由 

新增应用 urls.py 的路由配置：

from django.urls import path
from . import views

urlpatterns = [
    path('',views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name="project"),
    path('module/', views.module, name="module"),
]

路由地址“module”对应的视图函数，指向 views.py 中的 module 方法，下一步我们添加下该方法的处理。

3.4 定义视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
from .models import Project, Module


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

3.5 定义模板

1）新增 templates/module.html 模板：

{% extends 'base.html' %}
{% load static %}
{% block title %}模块{% endblock %}

{% block content %}
<form action="{% url 'module'%}" method="POST">
    {% csrf_token %}
    <input style="margin-left: 5px;" type="text" name="proj_name" value="{{ proj_name }}" placeholder="输入项目名称搜索模块">
    <input type="submit" value="搜索">
</form>

<div class="table-responsive">

    <table class="table table-striped">
        <thead>
        <tr>
            <th>id</th>
            <th>模块名称</th>
            <th>所属项目</th>
            <th>测试负责人</th>
            <th>模块描述</th>
            <th>创建时间</th>
            <th>更新时间</th>
            <th>测试结果统计</th>
        </tr>
        </thead>
        <tbody>

        {% for module in modules %}
        <tr>
            <td>{{ module.id }}</td>
            <td><a href="">{{ module.name }}</a></td>
            <td>{{ module.belong_project.name }}</td>
            <td>{{ module.test_owner }}</td>
            <td>{{ module.desc }}</td>
            <td>{{ module.create_time|date:"Y-n-d H:i" }}</td>
            <td>{{ module.update_time|date:"Y-n-d H:i" }}</td>
            <td><a href="">查看</a></td>
        </tr>
        {% endfor %}
        
        </tbody>
    </table>
</div>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if modules.has_previous %}
                <a class='active' href="?page={{ modules.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ modules.number }} 页 / 共 {{ modules.paginator.num_pages }} 页</span>

                {% if modules.has_next %}
                <a class='active' href="?page={{ modules.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

2）修改 base.html 模板，新增模块菜单栏：

<!DOCTYPE html>
<html lang="zh-CN">
{% load static %}
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
    <title>{% block title %}base{% endblock %}</title>

    <!-- Bootstrap -->
    <link href="{% static 'bootstrap/css/bootstrap.min.css' %}" rel="stylesheet">


    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    <script src="https://cdn.bootcss.com/html5shiv/3.7.3/html5shiv.min.js"></script>
    <script src="https://cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
    {% block css %}{% endblock %}
</head>
<body>
<nav class="navbar navbar-default">
    <div class="container-fluid">
        <!-- Brand and toggle get grouped for better mobile display -->
        <div class="navbar-header">
            <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#my-nav"
                    aria-expanded="false">
                <span class="sr-only">切换导航条</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>
            <a class="navbar-brand" href="/">自动化测试平台</a>
        </div>

        <div class="collapse navbar-collapse" id="my-nav">
            <ul class="nav navbar-nav">
                <li class="active"><a href="/project/">项目</a></li>
                <li class="active"><a href="/module/">模块</a></li>
            </ul>
            <ul class="nav navbar-nav navbar-right">
                {% if request.user.is_authenticated %}
                <li><a href="#">当前在线：{{ request.user.username }}</a></li>
                <li><a href="/logout">登出</a></li>
                {% else %}
                <li><a href="/login">登录</a></li>

                {% endif %}
            </ul>
        </div><!-- /.navbar-collapse -->
    </div><!-- /.container-fluid -->
</nav>

{% block content %}{% endblock %}


<!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
<script src="{% static 'js/jquery-3.4.1.js' %}"></script>
<!-- Include all compiled plugins (below), or include individual files as needed -->
<script src="{% static 'bootstrap/js/bootstrap.min.js' %}"></script>
</body>
</html>

 

4. 测试用例

4.1 定义模型类

1）在应用 models.py 中增加 TestCase 模型类：

from django.db import models
from smart_selects.db_fields import GroupedForeignKey  # 后台级联选择
from django.contrib.auth.models import User


class Project(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('项目名称', max_length=50, unique=True, null=False)
    proj_owner = models.CharField('项目负责人', max_length=20, null=False)
    test_owner = models.CharField('测试负责人', max_length=20, null=False)
    dev_owner = models.CharField('开发负责人', max_length=20, null=False)
    desc = models.CharField('项目描述', max_length=100, null=True)
    create_time = models.DateTimeField('项目创建时间', auto_now_add=True)
    update_time = models.DateTimeField('项目更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '项目信息表'
        verbose_name_plural = '项目信息表'


class Module(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('模块名称', max_length=50, null=False)
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE)
    test_owner = models.CharField('测试负责人', max_length=50, null=False)
    desc = models.CharField('简要描述', max_length=100, null=True)
    create_time = models.DateTimeField('创建时间', auto_now_add=True)
    update_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '模块信息表'
        verbose_name_plural = '模块信息表'


class TestCase(models.Model):
    id = models.AutoField(primary_key=True)
    case_name = models.CharField('用例名称', max_length=50, null=False)  # 如 register
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE, verbose_name='所属项目')
    belong_module = GroupedForeignKey(Module, "belong_project", on_delete=models.CASCADE, verbose_name='所属模块')
    request_data = models.CharField('请求数据', max_length=1024, null=False, default='')
    uri = models.CharField('接口地址', max_length=1024, null=False, default='')
    assert_key = models.CharField('断言内容', max_length=1024, null=True)
    maintainer = models.CharField('编写人员', max_length=1024, null=False, default='')
    extract_var = models.CharField('提取变量表达式', max_length=1024, null=True)  # 示例：userid||userid": (\d+)
    request_method = models.CharField('请求方式', max_length=1024, null=True)
    status = models.IntegerField(null=True, help_text="0：表示有效，1：表示无效，用于软删除")
    created_time = models.DateTimeField('创建时间', auto_now_add=True)
    updated_time = models.DateTimeField('更新时间', auto_now=True, null=True)
    user = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name='责任人', null=True)

    def __str__(self):
        return self.case_name

    class Meta:
        verbose_name = '测试用例表'
        verbose_name_plural = '测试用例表'

GroupedForeignKey 可以支持在 admin 新增数据时，展示该模型类的关联表数据。（需提前安装：pip install django-smart-selects）

2）数据迁移

在项目目录下，执行以下两个命令进行数据迁移（将模型类转换成数据库表）：

python manage.py makemigrations  # 生成迁移文件（模型类的信息）
python manage.py migrate  # 执行开始迁移（将模型类信息转换成数据库表）

4.2 后台 admin 添加数据

1）注册模型类到 admin

应用 admin.py 文件中增加如下代码：注册 TestCase 模型类到 admin 后台系统。

from django.contrib import admin
from . import models


class ProjectAdmin(admin.ModelAdmin):
    list_display = ("id", "name", "proj_owner", "test_owner", "dev_owner", "desc", "create_time", "update_time")

admin.site.register(models.Project, ProjectAdmin)


class ModuleAdmin(admin.ModelAdmin):
    list_display = ("id", "name", "belong_project", "test_owner", "desc", "create_time", "update_time")

admin.site.register(models.Module, ModuleAdmin)


class TestCaseAdmin(admin.ModelAdmin):
    list_display = (
        "id", "case_name", "belong_project", "belong_module", "request_data", "uri", "assert_key", "maintainer",
        "extract_var", "request_method", "status", "created_time", "updated_time", "user")

admin.site.register(models.TestCase, TestCaseAdmin)

2）登录 admin 系统，添加用例数据

访问 http://127.0.0.1:8000/admin/，进入测试用例表，添加数据：

添加用例数据时，页面如下：

• 所属项目和所属模块下拉选项是根据模型类中的 GroupedForeignKey 属性生成的，方便我们正确的关联数据。 
• 请求数据、断言内容、提取变量表达式等字段的定义，需要根据接口业务逻辑，以及后续运行逻辑的设计来输入。 

 

添加数据后如下所示： 

4.3 定义路由 

应用 urls.py：

from django.urls import path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
]

4.4 定义视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
from .models import Project, Module, TestCase


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 测试用例菜单
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = TestCase.objects.filter().order_by('id')
        print("testcases in testcase: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('testcases_list')
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
        test_cases = TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

4.5 定义模板文件

1）新增 templates/test_case.html 模板：

{% extends 'base.html' %}
{% load static %}
{% block title %}测试用例{% endblock %}

{% block content %}
<form action="" method="POST">
    {% csrf_token %}
    <div class="table-responsive">
        <table class="table table-striped">
            <thead>
            <tr>
                <th>用例名称</th>
                <th>所属项目</th>
                <th>所属模块</th>
                <th>接口地址</th>
                <th>请求方式</th>
                <th>请求数据</th>
                <th>断言key</th>
                <th>提取变量表达式</th>
            </tr>
            </thead>
            <tbody>

            {% for test_case in test_cases %}
            <tr>
                <td><a href="{% url 'test_case_detail' test_case.id%}">{{ test_case.case_name }}</a></td>
                <td>{{ test_case.belong_project.name }}</td>
                <td>{{ test_case.belong_module.name }}</td>
                <td>{{ test_case.uri }}</td>
                <td>{{ test_case.request_method }}</td>
                <td>{{ test_case.request_data }}</td>
                <td>{{ test_case.assert_key }}</td>
                <td>{{ test_case.extract_var }}</td>
            </tr>
            {% endfor %}
            </tbody>
        </table>

    </div>
</form>
{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if test_cases.has_previous %}
                <a class='active' href="?page={{ test_cases.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ test_cases.number }} 页 / 共 {{ test_cases.paginator.num_pages }} 页</span>

                {% if test_cases.has_next %}
                <a class='active' href="?page={{ test_cases.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

2）修改 base.html 模板：增加测试用例菜单。

<!DOCTYPE html>
<html lang="zh-CN">
{% load static %}
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
    <title>{% block title %}base{% endblock %}</title>

    <!-- Bootstrap -->
    <link href="{% static 'bootstrap/css/bootstrap.min.css' %}" rel="stylesheet">


    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    <script src="https://cdn.bootcss.com/html5shiv/3.7.3/html5shiv.min.js"></script>
    <script src="https://cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
    {% block css %}{% endblock %}
</head>
<body>
<nav class="navbar navbar-default">
    <div class="container-fluid">
        <!-- Brand and toggle get grouped for better mobile display -->
        <div class="navbar-header">
            <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#my-nav"
                    aria-expanded="false">
                <span class="sr-only">切换导航条</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>
            <a class="navbar-brand" href="/">自动化测试平台</a>
        </div>

        <div class="collapse navbar-collapse" id="my-nav">
            <ul class="nav navbar-nav">
                <li class="active"><a href="/project/">项目</a></li>
                <li class="active"><a href="/module/">模块</a></li>
                <li class="active"><a href="/test_case/">测试用例</a></li>
            </ul>
            <ul class="nav navbar-nav navbar-right">
                {% if request.user.is_authenticated %}
                <li><a href="#">当前在线：{{ request.user.username }}</a></li>
                <li><a href="/logout">登出</a></li>
                {% else %}
                <li><a href="/login">登录</a></li>

                {% endif %}
            </ul>
        </div><!-- /.navbar-collapse -->
    </div><!-- /.container-fluid -->
</nav>

{% block content %}{% endblock %}


<!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
<script src="{% static 'js/jquery-3.4.1.js' %}"></script>
<!-- Include all compiled plugins (below), or include individual files as needed -->
<script src="{% static 'bootstrap/js/bootstrap.min.js' %}"></script>
</body>
</html>

4.6 用例详情

目前用例列表中的字段仅包含用例的基本信息，下面继续加一下（点击用例名称跳转）用例详情页面，用于展示用例的全部字段信息，如创建时间、更新时间、维护人、创建人。

1）新增用例详情的路由配置

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
]

由于用例详情路由地址需要传路由变量“test_case_id”，该变量需要通过正则表达式进行匹配，在 Django2.0 后，路由地址用到正则时需要用到 re_path 来解析，便于 Django 正确的匹配视图函数，以及在浏览器地址栏正确的展示 url 地址。

2）增加视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
from .models import Project, Module, TestCase


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 测试用例菜单
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = TestCase.objects.filter().order_by('id')
        print("testcases in testcase: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('testcases_list')
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
        test_cases = TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

3）新增 templates/test_case_detail.html 模板

{% extends 'base.html' %}
{% load static %}
{% block title %}用例详情{% endblock %}

{% block content %}
<div class="table-responsive">
    <table class="table table-striped">
        <thead>
        <tr>
            <th width="3%">id</th>
            <th width="4%">接口名称</th>
            <th width="6%">所属项目</th>
            <th width="6%">所属模块</th>
            <th width="6%">接口地址</th>
            <th width="10%">请求数据</th>
            <th width="8%">断言内容</th>
            <th width="4%">编写人员</th>
            <th width="8%">提取变量表达式</th>
            <th width="4%">维护人</th>
            <th width="4%">创建人</th>
            <th width="6%">创建时间</th>
            <th width="6%">更新时间</th>
        </tr>
        </thead>
        <tbody>
        <tr>
            <td>{{ test_case.id }}</td>
            <td>{{ test_case.case_name }}</td>
            <td>{{ test_case.belong_project }}</td>
            <td>{{ test_case.belong_module }}</td>
            <td>{{ test_case.uri }}</td>
            <td>{{ test_case.request_data }}</td>
            <td>{{ test_case.assert_key }}</td>
            <td>{{ test_case.maintainer }}</td>
            <td>{{ test_case.extract_var }}</td>
            <td>{{ test_case.maintainer }}</td>
            <td>{{ test_case.user.username }}</td>
            <td>{{ test_case.created_time|date:"Y-n-d H:i" }}</td>
            <td>{{ test_case.updated_time|date:"Y-n-d H:i" }}</td>
        </tr>
        </tbody>
    </table>
</div>
{% endblock %}

4）修改 test_case.html 模板

添加用例名称的链接为用例详情路由地址：

{% extends 'base.html' %}
{% load static %}
{% block title %}测试用例{% endblock %}

{% block content %}
<form action="" method="POST">
    {% csrf_token %}
    <div class="table-responsive">
        <table class="table table-striped">
            <thead>
            <tr>
                <th>用例名称</th>
                <th>所属项目</th>
                <th>所属模块</th>
                <th>接口地址</th>
                <th>请求方式</th>
                <th>请求数据</th>
                <th>断言key</th>
                <th>提取变量表达式</th>
            </tr>
            </thead>
            <tbody>

            {% for test_case in test_cases %}
            <tr>
                <td><a href="{% url 'test_case_detail' test_case.id%}">{{ test_case.case_name }}</a></td>
                <td>{{ test_case.belong_project.name }}</td>
                <td>{{ test_case.belong_module.name }}</td>
                <td>{{ test_case.uri }}</td>
                <td>{{ test_case.request_method }}</td>
                <td>{{ test_case.request_data }}</td>
                <td>{{ test_case.assert_key }}</td>
                <td>{{ test_case.extract_var }}</td>
            </tr>
            {% endfor %}
            </tbody>
        </table>

    </div>
</form>
{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if test_cases.has_previous %}
                <a class='active' href="?page={{ test_cases.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ test_cases.number }} 页 / 共 {{ test_cases.paginator.num_pages }} 页</span>

                {% if test_cases.has_next %}
                <a class='active' href="?page={{ test_cases.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

4.7 模块页面展示所包含用例

1）新增模块页面的用例路由配置：

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
]

2）新增视图函数：

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
from .models import Project, Module, TestCase


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 测试用例菜单
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = TestCase.objects.filter().order_by('id')
        print("testcases in testcase: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('testcases_list')
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
        test_cases = TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = Module.objects.get(id=int(module_id))
    test_cases = TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至index视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

3）修改模块的模板文件：在模块名称链接中，添加对应测试用例的路由地址。

{% extends 'base.html' %}
{% load static %}
{% block title %}模块{% endblock %}

{% block content %}
<form action="{% url 'module'%}" method="POST">
    {% csrf_token %}
    <input style="margin-left: 5px;" type="text" name="proj_name" value="{{ proj_name }}" placeholder="输入项目名称搜索模块">
    <input type="submit" value="搜索">
</form>

<div class="table-responsive">

    <table class="table table-striped">
        <thead>
        <tr>
            <th>id</th>
            <th>模块名称</th>
            <th>所属项目</th>
            <th>测试负责人</th>
            <th>模块描述</th>
            <th>创建时间</th>
            <th>更新时间</th>
            <th>测试结果统计</th>
        </tr>
        </thead>
        <tbody>

        {% for module in modules %}
        <tr>
            <td>{{ module.id }}</td>
            <td><a href="{% url 'module_test_cases' module.id %}">{{ module.name }}</a></td>
            <td>{{ module.belong_project.name }}</td>
            <td>{{ module.test_owner }}</td>
            <td>{{ module.desc }}</td>
            <td>{{ module.create_time|date:"Y-n-d H:i" }}</td>
            <td>{{ module.update_time|date:"Y-n-d H:i" }}</td>
            <td><a href="">查看</a></td>
        </tr>
        {% endfor %}

        </tbody>
    </table>
</div>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if modules.has_previous %}
                <a class='active' href="?page={{ modules.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ modules.number }} 页 / 共 {{ modules.paginator.num_pages }} 页</span>

                {% if modules.has_next %}
                <a class='active' href="?page={{ modules.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

  

5. 用例集合

预期效果如下：

5.1 定义模型类

1）models.py 中新增 case_suite 模型类：

from django.db import models
from smart_selects.db_fields import GroupedForeignKey  # pip install django-smart-selects：后台级联选择
from django.contrib.auth.models import User


class Project(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('项目名称', max_length=50, unique=True, null=False)
    proj_owner = models.CharField('项目负责人', max_length=20, null=False)
    test_owner = models.CharField('测试负责人', max_length=20, null=False)
    dev_owner = models.CharField('开发负责人', max_length=20, null=False)
    desc = models.CharField('项目描述', max_length=100, null=True)
    create_time = models.DateTimeField('项目创建时间', auto_now_add=True)
    update_time = models.DateTimeField('项目更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '项目信息表'
        verbose_name_plural = '项目信息表'


class Module(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('模块名称', max_length=50, null=False)
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE)
    test_owner = models.CharField('测试负责人', max_length=50, null=False)
    desc = models.CharField('简要描述', max_length=100, null=True)
    create_time = models.DateTimeField('创建时间', auto_now_add=True)
    update_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '模块信息表'
        verbose_name_plural = '模块信息表'


class TestCase(models.Model):
    id = models.AutoField(primary_key=True)
    case_name = models.CharField('用例名称', max_length=50, null=False)  # 如 register
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE, verbose_name='所属项目')
    belong_module = GroupedForeignKey(Module, "belong_project", on_delete=models.CASCADE, verbose_name='所属模块')
    request_data = models.CharField('请求数据', max_length=1024, null=False, default='')
    uri = models.CharField('接口地址', max_length=1024, null=False, default='')
    assert_key = models.CharField('断言内容', max_length=1024, null=True)
    maintainer = models.CharField('编写人员', max_length=1024, null=False, default='')
    extract_var = models.CharField('提取变量表达式', max_length=1024, null=True)  # 示例：userid||userid": (\d+)
    request_method = models.CharField('请求方式', max_length=1024, null=True)
    status = models.IntegerField(null=True, help_text="0：表示有效，1：表示无效，用于软删除")
    created_time = models.DateTimeField('创建时间', auto_now_add=True)
    updated_time = models.DateTimeField('更新时间', auto_now=True, null=True)
    user = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name='责任人', null=True)

    def __str__(self):
        return self.case_name

    class Meta:
        verbose_name = '测试用例表'
        verbose_name_plural = '测试用例表'


class CaseSuite(models.Model):
    id = models.AutoField(primary_key=True)
    suite_desc = models.CharField('用例集合描述', max_length=100, blank=True, null=True)
    if_execute = models.IntegerField(verbose_name='是否执行', null=False, default=0, help_text='0：执行；1：不执行')
    test_case_model = models.CharField('测试执行模式', max_length=100, blank=True, null=True, help_text='data/keyword')
    creator = models.CharField(max_length=50, blank=True, null=True)
    create_time = models.DateTimeField('创建时间', auto_now=True)  # 创建时间-自动获取当前时间

    class Meta:
        verbose_name = '用例集合表'
        verbose_name_plural = '用例集合表'

2）数据迁移

在项目目录下，执行以下两个命令进行数据迁移（将模型类转换成数据库表）：

python manage.py makemigrations  # 生成迁移文件（模型类的信息）
python manage.py migrate  # 执行开始迁移（将模型类信息转换成数据库表）

5.2 后台 admin 添加数据

1）注册模型类到 admin.py：

from django.contrib import admin
from .import models


class ProjectAdmin(admin.ModelAdmin):
    list_display = ("id", "name", "proj_owner", "test_owner", "dev_owner", "desc", "create_time", "update_time")

admin.site.register(models.Project, ProjectAdmin)


class ModuleAdmin(admin.ModelAdmin):
    list_display = ("id", "name", "belong_project", "test_owner", "desc", "create_time", "update_time")

admin.site.register(models.Module, ModuleAdmin)


class TestCaseAdmin(admin.ModelAdmin):
    list_display = (
        "id", "case_name", "belong_project", "belong_module", "request_data", "uri", "assert_key", "maintainer",
        "extract_var", "request_method", "status", "created_time", "updated_time", "user")

admin.site.register(models.TestCase, TestCaseAdmin)


class CaseSuiteAdmin(admin.ModelAdmin):
    list_display = ("id", "suite_desc", "creator", "create_time")

admin.site.register(models.CaseSuite, CaseSuiteAdmin)

2）登录 admin 系统，进入用例集合表，添加数据：

5.3 定义路由 

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('test_suite/', views.test_suite, name="test_suite"),
]

5.4 定义视图

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
from .models import Project, Module, TestCase, CaseSuite


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 测试用例菜单
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = TestCase.objects.filter().order_by('id')
        print("testcases in testcase: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('testcases_list')
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
        test_cases = TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = Module.objects.get(id=int(module_id))
    test_cases = TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


@login_required
def case_suite(request):
    case_suites = CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

5.5 定义模板

新增 templates/case_suite.html 模板：

{% extends 'base.html' %}
{% load static %}
{% block title %}测试集合{% endblock %}
{% block content %}
<form action="" method="POST">
    {% csrf_token %}

    <div class="table-responsive">
        <table class="table table-striped">
            <thead>
            <tr>
                <th>id</th>
                <th>测试集合名称</th>
                <th>创建者</th>
                <th>创建时间</th>
                <th>查看/删除测试用例</th>
                <th>添加测试用例</th>
                <th>用例集合执行结果</th>
            </tr>
            </thead>
            <tbody>

            {% for case_suite in case_suites %}
            <tr>
                <td>{{ case_suite.id }}</td>
                <td>{{ case_suite.suite_desc }}</td>
                <td>{{ case_suite.creator }}</td>
                <td>{{ case_suite.create_time|date:"Y-n-d H:i" }}</td>
                <td><a href="">查看/删除测试用例</a></td>
                <td><a href="">添加测试用例</a></td>
                <td><a href="">查看用例集合执行结果</a></td>
            </tr>
            {% endfor %}
            </tbody>
        </table>
    </div>
</form>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if case_suites.has_previous %}
                <a class='active' href="?page={{ case_suites.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ case_suites.number }} 页/共 {{ case_suites.paginator.num_pages }} 页</span>

                {% if case_suites.has_next %}
                <a class='active' href="?page={{ case_suites.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

2）修改 base 模板：菜单栏新增“用例集合”。

<!DOCTYPE html>
<html lang="zh-CN">
{% load static %}
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
    <title>{% block title %}base{% endblock %}</title>

    <!-- Bootstrap -->
    <link href="{% static 'bootstrap/css/bootstrap.min.css' %}" rel="stylesheet">


    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    <script src="https://cdn.bootcss.com/html5shiv/3.7.3/html5shiv.min.js"></script>
    <script src="https://cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
    {% block css %}{% endblock %}
</head>
<body>
<nav class="navbar navbar-default">
    <div class="container-fluid">
        <!-- Brand and toggle get grouped for better mobile display -->
        <div class="navbar-header">
            <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#my-nav"
                    aria-expanded="false">
                <span class="sr-only">切换导航条</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>
            <a class="navbar-brand" href="/">自动化测试平台</a>
        </div>

        <div class="collapse navbar-collapse" id="my-nav">
            <ul class="nav navbar-nav">
                <li class="active"><a href="/project/">项目</a></li>
                <li class="active"><a href="/module/">模块</a></li>
                <li class="active"><a href="/test_case/">测试用例</a></li>
                <li class="active"><a href="/case_suite/">用例集合</a></li>
            </ul>
            <ul class="nav navbar-nav navbar-right">
                {% if request.user.is_authenticated %}
                <li><a href="#">当前在线：{{ request.user.username }}</a></li>
                <li><a href="/logout">登出</a></li>
                {% else %}
                <li><a href="/login">登录</a></li>

                {% endif %}
            </ul>
        </div><!-- /.navbar-collapse -->
    </div><!-- /.container-fluid -->
</nav>

{% block content %}{% endblock %}


<!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
<script src="{% static 'js/jquery-3.4.1.js' %}"></script>
<!-- Include all compiled plugins (below), or include individual files as needed -->
<script src="{% static 'bootstrap/js/bootstrap.min.js' %}"></script>
</body>
</html>

 

6. 用例集合添加测试用例

预期效果如下：

6.1 定义模型类

1）在 models.py 中，增加模型类 SuiteCase，记录用例集合所关联的用例。

from django.db import models
from smart_selects.db_fields import GroupedForeignKey  # pip install django-smart-selects：后台级联选择
from django.contrib.auth.models import User


class Project(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('项目名称', max_length=50, unique=True, null=False)
    proj_owner = models.CharField('项目负责人', max_length=20, null=False)
    test_owner = models.CharField('测试负责人', max_length=20, null=False)
    dev_owner = models.CharField('开发负责人', max_length=20, null=False)
    desc = models.CharField('项目描述', max_length=100, null=True)
    create_time = models.DateTimeField('项目创建时间', auto_now_add=True)
    update_time = models.DateTimeField('项目更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '项目信息表'
        verbose_name_plural = '项目信息表'


class Module(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('模块名称', max_length=50, null=False)
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE)
    test_owner = models.CharField('测试负责人', max_length=50, null=False)
    desc = models.CharField('简要描述', max_length=100, null=True)
    create_time = models.DateTimeField('创建时间', auto_now_add=True)
    update_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '模块信息表'
        verbose_name_plural = '模块信息表'


class TestCase(models.Model):
    id = models.AutoField(primary_key=True)
    case_name = models.CharField('用例名称', max_length=50, null=False)  # 如 register
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE, verbose_name='所属项目')
    belong_module = GroupedForeignKey(Module, "belong_project", on_delete=models.CASCADE, verbose_name='所属模块')
    request_data = models.CharField('请求数据', max_length=1024, null=False, default='')
    uri = models.CharField('接口地址', max_length=1024, null=False, default='')
    assert_key = models.CharField('断言内容', max_length=1024, null=True)
    maintainer = models.CharField('编写人员', max_length=1024, null=False, default='')
    extract_var = models.CharField('提取变量表达式', max_length=1024, null=True)  # 示例：userid||userid": (\d+)
    request_method = models.CharField('请求方式', max_length=1024, null=True)
    status = models.IntegerField(null=True, help_text="0：表示有效，1：表示无效，用于软删除")
    created_time = models.DateTimeField('创建时间', auto_now_add=True)
    updated_time = models.DateTimeField('更新时间', auto_now=True, null=True)
    user = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name='责任人', null=True)

    def __str__(self):
        return self.case_name

    class Meta:
        verbose_name = '测试用例表'
        verbose_name_plural = '测试用例表'


class CaseSuite(models.Model):
    id = models.AutoField(primary_key=True)
    suite_desc = models.CharField('用例集合描述', max_length=100, blank=True, null=True)
    if_execute = models.IntegerField(verbose_name='是否执行', null=False, default=0, help_text='0：执行；1：不执行')
    test_case_model = models.CharField('测试执行模式', max_length=100, blank=True, null=True, help_text='data/keyword')
    creator = models.CharField(max_length=50, blank=True, null=True)
    create_time = models.DateTimeField('创建时间', auto_now=True)  # 创建时间-自动获取当前时间

    class Meta:
        verbose_name = "用例集合表"
        verbose_name_plural = '用例集合表'


class SuiteCase(models.Model):
    id = models.AutoField(primary_key=True)
    case_suite = models.ForeignKey(CaseSuite, on_delete=models.CASCADE, verbose_name='用例集合')
    test_case = models.ForeignKey(TestCase, on_delete=models.CASCADE, verbose_name='测试用例')
    status = models.IntegerField(verbose_name='是否有效', null=False, default=1, help_text='0：有效，1：无效')
    create_time = models.DateTimeField('创建时间', auto_now=True)  # 创建时间-自动获取当前时间

2）数据迁移

在项目目录下，执行以下两个命令进行数据迁移（将模型类转换成数据库表）：

python manage.py makemigrations  # 生成迁移文件（模型类的信息）
python manage.py migrate  # 执行开始迁移（将模型类信息转换成数据库表）

6.2 定义路由 

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('case_suite/', views.case_suite, name="case_suite"),
    re_path('add_case_in_suite/(?P<suite_id>[0-9]+)', views.add_case_in_suite, name="add_case_in_suite"),
]

6.3 定义视图

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
from .models import Project, Module, TestCase, CaseSuite, SuiteCase


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 测试用例页
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = TestCase.objects.filter().order_by('id')
        print("testcases in testcase: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('testcases_list')
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
        test_cases = TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = Module.objects.get(id=int(module_id))
    test_cases = TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合页
@login_required
def case_suite(request):
    case_suites = CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

6.4 定义模板文件

1）新增添加测试用例页的模板文件 templates/add_case_in_suite.html：

{% extends 'base.html' %}
{% load static %}
{% block title %}管理测试集合{% endblock %}
{% block content %}

<script type="text/javascript">
    //页面加载的时候,所有的复选框都是未选中的状态
    function checkOrCancelAll() {
        var all_check = document.getElementById("all_check");//1.获取all的元素对象
        var all_check = all_check.checked;//2.获取选中状态
        var allCheck = document.getElementsByName("testcases_list");//3.若checked=true,将所有的复选框选中,checked=false,将所有的复选框取消
        //4.循环遍历取出每一个复选框中的元素
        if (all_check)//全选
        {
            for (var i = 0; i < allCheck.length; i++) {
                //设置复选框的选中状态
                allCheck[i].checked = true;
            }
        } else//取消全选
        {
            for (var i = 0; i < allCheck.length; i++) {
                allCheck[i].checked = false;
            }
        }
    }

    function ischecked() {
        var allCheck = document.getElementsByName("testcases_list");//3.若checked=true,将所有的复选框选中,checked=false,将所有的复选框取消
        for (var i = 0; i < allCheck.length; i++) {
            if (allCheck[i].checked == true) {
                alert("成功添加所选测试用例至测试集合【{{case_suite.suite_desc}}】");
                return true
            }
        }
        alert("请选择要添加的测试用例！")
        return false
    }



</script>
<form action="" method="POST">
    {% csrf_token %}
    <input type="submit" id="all_check1" value='添加测试用例' onclick="return ischecked()"/>
    <div class="table-responsive">
        <table class="table table-striped">
            <thead>
            <tr>
                <th><input type="checkbox" id="all_check" onclick="checkOrCancelAll();"/>id</th>
                <th>用例名称</th>
                <th>所属项目</th>
                <th>所属模块</th>
                <th>编写人员</th>
                <th>创建时间</th>
                <th>更新时间</th>
                <th>创建用例用户名</th>
            </tr>
            </thead>
            <tbody>
            {% for test_case in test_cases %}
            <tr>
                <td><input type="checkbox" value="{{ test_case.id }}" name="testcases_list"> {{ test_case.id }}</td>
                <td><a href="{% url 'test_case_detail' test_case.id%}">{{ test_case.case_name }}</a></td>
                <td>{{ test_case.belong_project.name }}</td>
                <td>{{ test_case.belong_module.name }}</td>
                <td>{{ test_case.maintainer }}</td>
                <td>{{ test_case.created_time|date:"Y-n-d H:i" }}</td>
                <td>{{ test_case.updated_time|date:"Y-n-d H:i" }}</td>
                <td>{{ test_case.user.username }}</td>
            </tr>
            {% endfor %}
            </tbody>
        </table>
    </div>
</form>
{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if test_cases.has_previous %}
                <a class='active' href="?page={{ test_cases.previous_page_number }}">上一页</a>
                {% endif %}
                <span class="current">
                    第 {{ test_cases.number }} 页 / 共 {{ test_cases.paginator.num_pages }} 页</span>
                {% if test_cases.has_next %}
                <a class='active' href="?page={{ test_cases.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

2）修改用例集合模板文件 templates/case_suite.html：修改“添加测试用例”的链接地址。

{% extends 'base.html' %}
{% load static %}
{% block title %}用例集合{% endblock %}
{% block content %}
<form action="" method="POST">
    {% csrf_token %}

    <div class="table-responsive">
        <table class="table table-striped">
            <thead>
            <tr>
                <th>id</th>
                <th>测试集合名称</th>
                <th>创建者</th>
                <th>创建时间</th>
                <th>查看/删除测试用例</th>
                <th>添加测试用例</th>
                <th>用例集合执行结果</th>
            </tr>
            </thead>
            <tbody>

            {% for case_suite in case_suites %}
            <tr>
                <td>{{ case_suite.id }}</td>
                <td>{{ case_suite.suite_desc }}</td>
                <td>{{ case_suite.creator }}</td>
                <td>{{ case_suite.create_time|date:"Y-n-d H:i" }}</td>
                <td><a href="">查看/删除测试用例</a></td>
                <td><a href="{% url 'add_case_in_suite' case_suite.id %}">添加测试用例</a></td>
                <td><a href="">查看用例集合执行结果</a></td>
            </tr>
            {% endfor %}
            </tbody>
        </table>
    </div>
</form>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if case_suites.has_previous %}
                <a class='active' href="?page={{ case_suites.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ case_suites.number }} 页 / 共 {{ case_suites.paginator.num_pages }} 页</span>

                {% if case_suites.has_next %}
                <a class='active' href="?page={{ case_suites.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

 

7. 用例集合查看/删除测试用例

预期效果如下：

 7.1 定义路由

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('case_suite/', views.case_suite, name="case_suite"),
    re_path('add_case_in_suite/(?P<suite_id>[0-9]+)', views.add_case_in_suite, name="add_case_in_suite"),
    re_path('show_and_delete_case_in_suite/(?P<suite_id>[0-9]+)', views.show_and_delete_case_in_suite, name="show_and_delete_case_in_suite"),
]

7.2 定义视图函数 

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
from .models import Project, Module, TestCase, CaseSuite, SuiteCase, InterfaceServer
from .task import case_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目页
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块页
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例页
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = TestCase.objects.filter().order_by('id')
        print("testcases in testcase: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('testcases_list')
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
        test_cases = TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = Module.objects.get(id=int(module_id))
    test_cases = TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合页
@login_required
def case_suite(request):
    case_suites = CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = CaseSuite.objects.get(id=suite_id)
    test_cases = SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

7.2 定义模板文件

1）新建 templates/show_and_delete_case_in_suite.html：

{% extends 'base.html' %}
{% load static %}
{% block title %}查看/删除测试用例{% endblock %}
{% block content %}

<script type="text/javascript">
    //页面加载的时候,所有的复选框都是未选中的状态
    function checkOrCancelAll() {
        var all_check = document.getElementById("all_check");//1.获取all的元素对象
        var all_check = all_check.checked;//2.获取选中状态
        var allCheck = document.getElementsByName("test_cases_list");//3.若checked=true,将所有的复选框选中,checked=false,将所有的复选框取消
        //4.循环遍历取出每一个复选框中的元素
        if (all_check)//全选
        {

            for (var i = 0; i < allCheck.length; i++) {
                //设置复选框的选中状态
                allCheck[i].checked = true;
            }

        } else//取消全选
        {
            for (var i = 0; i < allCheck.length; i++) {
                allCheck[i].checked = false;
            }
        }
    }

    function ischecked() {

        var allCheck = document.getElementsByName("test_cases_list");//3.若checked=true,将所有的复选框选中,checked=false,将所有的复选框取消
        for (var i = 0; i < allCheck.length; i++) {

            if (allCheck[i].checked == true) {
                alert("所选用例删除成功！");
                return true
            }
        }
        alert("请选择要删除的测试用例！")
        return false
    }


</script>

<div><p style="margin-left: 5px;">测试集合名称：<b>{{case_suite.suite_desc}}</b></p>
    <div>
        <form action="" method="POST">
            {% csrf_token %}
            <input style="margin-left: 5px;" type="submit" id="all_check1" value='删除测试集合用例' onclick="return ischecked()"/>
            <div class="table-responsive">
                <table class="table table-striped">
                    <thead>
                    <tr>
                        <th width="4%"><input type="checkbox" id="all_check" onclick="checkOrCancelAll();"/>全选</th>
                        <th width="6%">用例序号</th>
                        <th>用例名称</th>
                        <th>所属项目</th>
                        <th>所属模块</th>
                        <th>编写人员</th>
                        <th>创建时间</th>
                        <th>更新时间</th>
                        <th>创建用例用户名</th>
                    </tr>
                    </thead>
                    <tbody>

                    {% for test_case in test_cases %}
                    <tr>
                        <td><input type="checkbox" value="{{ test_case.test_case.id }}" name="test_cases_list"></td>
                        <td>{{ test_case.test_case.id }}</td>
                        <td><a href="{% url 'test_case_detail' test_case.test_case.id%}">{{ test_case.test_case.case_name }}</a></td>
                        <td>{{ test_case.test_case.belong_project.name }}</td>
                        <td>{{ test_case.test_case.belong_module.name }}</td>
                        <td>{{ test_case.test_case.maintainer }}</td>
                        <td>{{ test_case.test_case.created_time|date:"Y-n-d H:i" }}</td>
                        <td>{{ test_case.test_case.updated_time|date:"Y-n-d H:i" }}</td>
                        <td>{{ test_case.test_case.user.username }}</td>
                    </tr>
                    {% endfor %}
                    </tbody>
                </table>
            </div>
        </form>

        {# 实现分页标签的代码 #}
        {# 这里使用 bootstrap 渲染页面 #}
        <div id="pages" class="text-center">
            <nav>
                <ul class="pagination">
                    <li class="step-links">
                        {% if test_cases.has_previous %}
                        <a class='active' href="?page={{ test_cases.previous_page_number }}">上一页</a>
                        {% endif %}

                        <span class="current">
                    第 {{ test_cases.number }} 页 / 共 {{ test_cases.paginator.num_pages }} 页</span>

                        {% if test_cases.has_next %}
                        <a class='active' href="?page={{ test_cases.next_page_number }}">下一页</a>
                        {% endif %}
                    </li>
                </ul>
            </nav>
        </div>
    </div>
</div>
{% endblock %}

2）修改 templates/case_suite.html：增加“查看/删除测试用例”链接

{% extends 'base.html' %}
{% load static %}
{% block title %}用例集合{% endblock %}
{% block content %}
<form action="" method="POST">
    {% csrf_token %}

    <div class="table-responsive">
        <table class="table table-striped">
            <thead>
            <tr>
                <th>id</th>
                <th>测试集合名称</th>
                <th>创建者</th>
                <th>创建时间</th>
                <th>查看/删除测试用例</th>
                <th>添加测试用例</th>
                <th>用例集合执行结果</th>
            </tr>
            </thead>
            <tbody>

            {% for case_suite in case_suites %}
            <tr>
                <td>{{ case_suite.id }}</td>
                <td>{{ case_suite.suite_desc }}</td>
                <td>{{ case_suite.creator }}</td>
                <td>{{ case_suite.create_time|date:"Y-n-d H:i" }}</td>
                <td><a href="{% url 'show_and_delete_case_in_suite' case_suite.id %}">查看/删除测试用例</a></td>
                <td><a href="{% url 'add_case_in_suite' case_suite.id %}">添加测试用例</a></td>
                <td><a href="">查看用例集合执行结果</a></td>
            </tr>
            {% endfor %}
            </tbody>
        </table>
    </div>
</form>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if case_suites.has_previous %}
                <a class='active' href="?page={{ case_suites.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ case_suites.number }} 页 / 共 {{ case_suites.paginator.num_pages }} 页</span>

                {% if case_suites.has_next %}
                <a class='active' href="?page={{ case_suites.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

 

8. 测试用例执行 

预期效果如下：

用例执行逻辑如下：

1. 前端提交用例 id 列表到后台，后台获取每一条用例的信息；
2. 后台获取域名信息、用例 id 列表；
3. 对用例的请求数据进行变量的参数化、函数化等预处理操作；
4. 根据先后顺序进行接口请求，并对响应数据进行断言；
5. 根据用例中的提取变量表达式，从断言成功的响应数据中提取关联变量值用于后续用例使用。

8.1 修改测试用例页模板文件：前端提交用例信息 

templates/test_case.html：

{% extends 'base.html' %}
{% load static %}
{% block title %}测试用例{% endblock %}

{% block content %}
<script type="text/javascript">
        //页面加载的时候,所有的复选框都是未选中的状态
        function checkOrCancelAll() {
            var all_check = document.getElementById("all_check");  //1.获取all的元素对象
            var all_check = all_check.checked;  //2.获取选中状态
            //3.若checked=true,将所有的复选框选中；checked=false,将所有的复选框取消
            var allCheck = document.getElementsByName("test_cases_list");
            //4.循环遍历取出每一个复选框中的元素
            if (all_check)//全选
            {
                for (var i = 0; i < allCheck.length; i++) {
                    //设置复选框的选中状态
                    allCheck[i].checked = true;
                }
            } else//取消全选
            {
                for (var i = 0; i < allCheck.length; i++) {
                    allCheck[i].checked = false;
                }
            }
        }

        function ischecked() {
            //3.若checked=true,将所有的复选框选中,checked=false,将所有的复选框取消
            var allCheck = document.getElementsByName("test_cases_list");
            for (var i = 0; i < allCheck.length; i++) {
                if (allCheck[i].checked == true) {
                    alert("所需执行的测试用例提交成功！");
                    return true
                }
            }
            alert("请选择要执行的测试用例！")
            return false
        }

</script>

<form action="" method="POST">
    {% csrf_token %}
    <input style="margin-left: 5px;" type="submit" value='执行测试用例' onclick="return ischecked()"/>
    <span style="margin-left: 5px;">运行环境：</span>
    <select name="env">
        <option selected value="dev">dev</option>
        <option value="prod">prod</option>
    </select>
    <div class="table-responsive">
        <table class="table table-striped">
            <thead>
            <tr>
                <th><input type="checkbox" id="all_check" onclick="checkOrCancelAll();"/>全选</th>
                <th>用例名称</th>
                <th>所属项目</th>
                <th>所属模块</th>
                <th>接口地址</th>
                <th>请求方式</th>
                <th>请求数据</th>
                <th>断言key</th>
                <th>提取变量表达式</th>
            </tr>
            </thead>
            <tbody>

            {% for test_case in test_cases %}
            <tr>
                <td><input type="checkbox" value="{{ test_case.id }}" name="test_cases_list"> {{ test_case.id }}</td>
                <td><a href="{% url 'test_case_detail' test_case.id%}">{{ test_case.case_name }}</a></td>
                <td>{{ test_case.belong_project.name }}</td>
                <td>{{ test_case.belong_module.name }}</td>
                <td>{{ test_case.uri }}</td>
                <td>{{ test_case.request_method }}</td>
                <td>{{ test_case.request_data }}</td>
                <td>{{ test_case.assert_key }}</td>
                <td>{{ test_case.extract_var }}</td>
            </tr>
            {% endfor %}
            </tbody>
        </table>

    </div>
</form>
{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if test_cases.has_previous %}
                <a class='active' href="?page={{ test_cases.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ test_cases.number }} 页 / 共 {{ test_cases.paginator.num_pages }} 页</span>

                {% if test_cases.has_next %}
                <a class='active' href="?page={{ test_cases.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

8.2 定义接口地址模型类

models.py：

from django.db import models
from smart_selects.db_fields import GroupedForeignKey  # pip install django-smart-selects：后台级联选择
from django.contrib.auth.models import User


class Project(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('项目名称', max_length=50, unique=True, null=False)
    proj_owner = models.CharField('项目负责人', max_length=20, null=False)
    test_owner = models.CharField('测试负责人', max_length=20, null=False)
    dev_owner = models.CharField('开发负责人', max_length=20, null=False)
    desc = models.CharField('项目描述', max_length=100, null=True)
    create_time = models.DateTimeField('项目创建时间', auto_now_add=True)
    update_time = models.DateTimeField('项目更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '项目信息表'
        verbose_name_plural = '项目信息表'


class Module(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('模块名称', max_length=50, null=False)
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE)
    test_owner = models.CharField('测试负责人', max_length=50, null=False)
    desc = models.CharField('简要描述', max_length=100, null=True)
    create_time = models.DateTimeField('创建时间', auto_now_add=True)
    update_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '模块信息表'
        verbose_name_plural = '模块信息表'


class TestCase(models.Model):
    id = models.AutoField(primary_key=True)
    case_name = models.CharField('用例名称', max_length=50, null=False)  # 如 register
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE, verbose_name='所属项目')
    belong_module = GroupedForeignKey(Module, "belong_project", on_delete=models.CASCADE, verbose_name='所属模块')
    request_data = models.CharField('请求数据', max_length=1024, null=False, default='')
    uri = models.CharField('接口地址', max_length=1024, null=False, default='')
    assert_key = models.CharField('断言内容', max_length=1024, null=True)
    maintainer = models.CharField('编写人员', max_length=1024, null=False, default='')
    extract_var = models.CharField('提取变量表达式', max_length=1024, null=True)  # 示例：userid||userid": (\d+)
    request_method = models.CharField('请求方式', max_length=1024, null=True)
    status = models.IntegerField(null=True, help_text="0：表示有效，1：表示无效，用于软删除")
    created_time = models.DateTimeField('创建时间', auto_now_add=True)
    updated_time = models.DateTimeField('更新时间', auto_now=True, null=True)
    user = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name='责任人', null=True)

    def __str__(self):
        return self.case_name

    class Meta:
        verbose_name = '测试用例表'
        verbose_name_plural = '测试用例表'


class CaseSuite(models.Model):
    id = models.AutoField(primary_key=True)
    suite_desc = models.CharField('用例集合描述', max_length=100, blank=True, null=True)
    if_execute = models.IntegerField(verbose_name='是否执行', null=False, default=0, help_text='0：执行；1：不执行')
    test_case_model = models.CharField('测试执行模式', max_length=100, blank=True, null=True, help_text='data/keyword')
    creator = models.CharField(max_length=50, blank=True, null=True)
    create_time = models.DateTimeField('创建时间', auto_now=True)  # 创建时间-自动获取当前时间

    class Meta:
        verbose_name = "用例集合表"
        verbose_name_plural = '用例集合表'


class SuiteCase(models.Model):
    id = models.AutoField(primary_key=True)
    case_suite = models.ForeignKey(CaseSuite, on_delete=models.CASCADE, verbose_name='用例集合')
    test_case = models.ForeignKey(TestCase, on_delete=models.CASCADE, verbose_name='测试用例')
    status = models.IntegerField(verbose_name='是否有效', null=False, default=1, help_text='0：有效，1：无效')
    create_time = models.DateTimeField('创建时间', auto_now=True)  # 创建时间-自动获取当前时间


class InterfaceServer(models.Model):
    id = models.AutoField(primary_key=True)
    env = models.CharField('环境', max_length=50, null=False, default='')
    ip = models.CharField('ip', max_length=50, null=False, default='')
    port = models.CharField('端口', max_length=100, null=False, default='')
    remark = models.CharField('备注', max_length=100, null=True)
    create_time = models.DateTimeField('创建时间', auto_now_add=True)
    update_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.env

    class Meta:
        verbose_name = '接口地址配置表'
        verbose_name_plural = '接口地址配置表'

执行数据迁移：

python manage.py makemigrations
python manage.py migrate

admin.py：

from django.contrib import admin
from .import models


class ProjectAdmin(admin.ModelAdmin):
    list_display = ("id", "name", "proj_owner", "test_owner", "dev_owner", "desc", "create_time", "update_time")

admin.site.register(models.Project, ProjectAdmin)


class ModuleAdmin(admin.ModelAdmin):
    list_display = ("id", "name", "belong_project", "test_owner", "desc", "create_time", "update_time")

admin.site.register(models.Module, ModuleAdmin)


class TestCaseAdmin(admin.ModelAdmin):
    list_display = (
        "id", "case_name", "belong_project", "belong_module", "request_data", "uri", "assert_key", "maintainer",
        "extract_var", "request_method", "status", "created_time", "updated_time", "user")

admin.site.register(models.TestCase, TestCaseAdmin)


class CaseSuiteAdmin(admin.ModelAdmin):
    list_display = ("id", "suite_desc", "creator", "create_time")

admin.site.register(models.CaseSuite, CaseSuiteAdmin)

30 
class InterfaceServerAdmin(admin.ModelAdmin):
    list_display = ("id", "env", "ip", "port", "remark", "create_time")

admin.site.register(models.InterfaceServer, InterfaceServerAdmin)

登录 admin 系统，添加地址配置数据：

8.3 修改测试用例视图函数，后台执行用例

1）Redis 持久化递增唯一数

在本工程中，我们使用 Redis 来维护一个每次调用函数来就会递增的数值，供注册接口的注册用户名拼接使用，避免注册接口请求数据重复使用问题。

1.1）Redis 持久化配置

修改 redis.windows.conf：

appendonly yes  # 每次更新操作后进行日志记录
appendfsync everysec  # 每秒同步一次（默认值）

1.2）启动 Redis 服务端：

redis-server.exe redis.windows.conf

2）请求/响应数据处理

在应用目录下新建 utils 包，用于封装接口请求的相关函数。

data_process.py

该模块实现了对接口请求的所需工具函数，如获取递增唯一数（供注册用户名使用）、md5 加密（用于登录密码加密）、请求数据预处理、响应数据断言等功能。

• get_unique_num_value()：用于获取每次递增的唯一数
  • 该函数的目标是解决注册用户名重复的问题。
  • 虽然可以在赋值注册用户名变量时，采用前缀字符串拼接随机数的方式，但是用随机数的方式仍然是有可能出现用户名重复的情况。因此，可以在单独的一个文件中维护一个数字，每次请求注册接口之前，先读取该文件中的数字，拼接用户名前缀字符串。读取完之后，再把这个数字进行加一的操作并保存，即每读取一次这个数字之后，就做一次修改，进而保证每次拼接的用户名都是唯一的，避免出现因为用户名重复导致用例执行失败的情况。
• data_preprocess()：对请求数据进行预处理：参数化及函数化。
• data_postprocess()：将响应数据需要关联的参数保存进全局变量，供后续接口使用。
• assert_result()：对响应数据进行关键字断言。

import re
import hashlib
import os
import json
import traceback
import redis
from InterfaceAutoTest.settings import redis_port


# 连接redis
pool = redis.ConnectionPool(host='localhost', port=redis_port, decode_responses=True)
redis_obj = redis.Redis(connection_pool=pool)


# 初始化框架工程中的全局变量，存储在测试数据中的唯一值数据
# 框架工程中若要使用字典中的任意一个变量，则每次使用后，均需要将字典中的value值进行加1操作。
def get_unique_number_value(unique_number):
    data = None
    try:
        redis_value = redis_obj.get(unique_number)  # {"unique_number": 666}
        if redis_value:
            data = redis_value
            print("全局唯一数当前生成的值是：%s" % data)
            # 把redis中key为unique_number的值进行加一操作，以便下提取时保持唯一
            redis_obj.set(unique_number, int(redis_value) + 1)
        else:
            data = 1000  # 初始化递增数值
            redis_obj.set(unique_number, data)
    except Exception as e:
        print("获取全局唯一数变量值失败，请求的全局唯一数变量是%s,异常原因如下：%s" % (unique_number, traceback.format_exc()))
        data = None
    finally:
        return data


def md5(s):
    m5 = hashlib.md5()
    m5.update(s.encode("utf-8"))
    md5_value = m5.hexdigest()
    return md5_value


# 请求数据预处理：参数化、函数化
# 将请求数据中包含的${变量名}的字符串部分，替换为唯一数或者全局变量字典中对应的全局变量
def data_preprocess(global_key, requestData):
    try:
        # 匹配注册用户名参数，即"${unique_num...}"的格式，并取出本次请求的随机数供后续接口的用户名参数使用
        if re.search(r"\$\{unique_num\d+\}", requestData):
            var_name = re.search(r"\$\{(unique_num\d+)\}", requestData).group(1)  # 获取用户名参数
            print("用户名变量:%s" % var_name)
            var_value = get_unique_number_value(var_name)
            print("用户名变量值: %s" % var_value)
            requestData = re.sub(r"\$\{unique_num\d+\}", str(var_value), requestData)
            var_name = var_name.split("_")[1]
            print("关联的用户名变量: %s" % var_name)
            # "xxxkey" : "{'var_name': var_value}"
            global_var = json.loads(os.environ[global_key])
            global_var[var_name] = var_value
            os.environ[global_key] = json.dumps(global_var)
            print("用户名唯一数参数化后的全局变量【os.environ[global_key]】: {}".format(os.environ[global_key]))
        # 函数化，如密码加密"${md5(...)}"的格式
        if re.search(r"\$\{\w+\(.+\)\}", requestData):
            var_pass = re.search(r"\$\{(\w+\(.+\))\}", requestData).group(1)  # 获取密码参数
            print("需要函数化的变量: %s" % var_pass)
            print("函数化后的结果: %s" % eval(var_pass))
            requestData = re.sub(r"\$\{\w+\(.+\)\}", eval(var_pass), requestData)  # 将requestBody里面的参数内容通过eval修改为实际变量值
            print("函数化后的请求数据: %s" % requestData)  # requestBody是拿到的请求时发送的数据
        # 其余变量参数化
        if re.search(r"\$\{(\w+)\}", requestData):
            print("需要参数化的变量: %s" % (re.findall(r"\$\{(\w+)\}", requestData)))
            for var_name in re.findall(r"\$\{(\w+)\}", requestData):
                requestData = re.sub(r"\$\{%s\}" % var_name, str(json.loads(os.environ[global_key])[var_name]), requestData)
        print("变量参数化后的最终请求数据: %s" % requestData)
        print("数据参数后的最终全局变量【os.environ[global_key]】: {}".format(os.environ[global_key]))
        return 0, requestData, ""
    except Exception as e:
        print("请求数据预处理发生异常，error：{}".format(traceback.format_exc()))
        return 1, {}, traceback.format_exc()


# 响应数据提取关联参数
def data_postprocess(global_key, response_data, extract_var):
    print("需提取的关联变量：%s" % extract_var)
    var_name = extract_var.split("||")[0]
    print("关联变量名：%s" % var_name)
    regx_exp = extract_var.split("||")[1]
    print("关联变量正则：%s" % regx_exp)
    if re.search(regx_exp, response_data):
        global_vars = json.loads(os.environ[global_key])
        print("关联前的全局变量：{}".format(global_vars))
        global_vars[var_name] = re.search(regx_exp, response_data).group(1)
        os.environ[global_key] = json.dumps(global_vars)
        print("关联前的全局变量：{}".format(os.environ[global_key]))
    return


# 响应数据 断言处理
def assert_result(response_obj, key_word):
    try:
        # 多个断言关键字
        if '&&' in key_word:
            key_word_list = key_word.split('&&')
            print("断言关键字列表：%s" % key_word_list)
            # 断言结果标识符
            flag = True
            exception_info = ''
            # 遍历分隔出来的断言关键词列表
            for key_word in key_word_list:
                # 如果断言词非空，则进行断言
                if key_word:
                    # 没查到断言词则认为是断言失败
                    if not (key_word in json.dumps(response_obj.json(), ensure_ascii=False)):
                        print("断言关键字【{}】匹配失败".format(key_word))
                        flag = False  # 只要有一个断言词匹配失败，则整个接口断言失败
                        exception_info = "keyword: {} not matched from response, assert failed".format(key_word)
                    else:
                        print("断言关键字【{}】匹配成功".format(key_word))
            if flag:
                print("接口断言成功！")
            else:
                print("接口断言失败！")
            return flag, exception_info
        # 单个断言关键字
        else:
            if key_word in json.dumps(response_obj.json(), ensure_ascii=False):
                print("接口断言【{}】匹配成功！".format(key_word))
                return True, ''
            else:
                print("接口断言【{}】匹配失败！".format(key_word))
                return False, ''
    except Exception as e:
        return False, traceback.format_exc()


# 测试代码
if __name__ == "__main__":
    print(get_unique_number_value("unique_num1"))

request_process.py

该模块实现了对接口请求的封装。

import requests
import json
# from Util.Log import logger


# 此函数封装了get请求、post和put请求的方法
def request_process(url, request_method, request_content):
    print("-------- 开始调用接口 --------")
    if request_method == "get":
        try:
            if isinstance(request_content, dict):
                print("接口地址：%s" % url)
                print("请求数据：%s" % request_content)
                r = requests.get(url, params=json.dumps(request_content))
            else:
                r = requests.get(url+str(request_content))
                print("接口地址：%s" % r.url)
                print("请求数据：%s" % request_content)

        except Exception as e:
            print("get方法请求发生异常：请求的url是%s, 请求的内容是%s\n发生的异常信息如下：%s" % (url, request_content, e))
            r = None
        return r
    elif request_method == "post":
        try:
            if isinstance(request_content, dict):
                print("接口地址：%s" % url)
                print("请求数据：%s" % json.dumps(request_content))
                r = requests.post(url, data=json.dumps(request_content))
            else:
                raise ValueError
        except ValueError as e:
            print("post方法请求发生异常：请求的url是%s, 请求的内容是%s\n发生的异常信息如下：%s" % (url, request_content, "请求参数不是字典类型"))
            r = None
        except Exception as e:
            print("post方法请求发生异常：请求的url是%s, 请求的内容是%s\n发生的异常信息如下：%s" % (url, request_content, e))
            r = None
        return r
    elif request_method == "put":
        try:
            if isinstance(request_content, dict):
                print("接口地址：%s" % url)
                print("请求数据：%s" % json.dumps(request_content))
                r = requests.put(url,  data=json.dumps(request_content))
            else:
                raise ValueError
        except ValueError as e:
            print("put方法请求发生异常：请求的url是%s, 请求的内容是%s\n发生的异常信息如下：%s" % (url,  request_content, "请求参数不是字典类型"))
            r = None
        except Exception as e:
            print("put方法请求发生异常：请求的url是%s, 请求的内容是%s\n发生的异常信息如下：%s" % (url, request_content, e))
            r = None
        return r

3）封装接口用例执行方法

在应用目录下新建 task.py： 

import time
import os
import traceback
import json
from . import models
from .utils.data_process import data_preprocess, assert_result, data_postprocess
from .utils.request_process import request_process


def case_task(test_case_id_list, server_address):
    global_key = 'case'+ str(int(time.time() * 100000))
    os.environ[global_key] = '{}'
    print()
    print("全局变量标识符【global_key】: {}".format(global_key))
    print("全局变量内容【os.environ[global_key]】: {}".format(os.environ[global_key]))
    for test_case_id in test_case_id_list:
        print()
        test_case = models.TestCase.objects.filter(id=int(test_case_id))[0]
        print("######### 开始执行用例【{}】 #########".format(test_case))
        execute_start_time = time.time()  # 记录时间戳，便于计算总耗时（毫秒）
        request_data = test_case.request_data
        extract_var = test_case.extract_var
        assert_key = test_case.assert_key
        interface_name = test_case.uri
        belong_project = test_case.belong_project
        belong_module = test_case.belong_module
        maintainer = test_case.maintainer
        request_method = test_case.request_method
        print("初始请求数据: {}".format(request_data))
        print("关联参数: {}".format(extract_var))
        print("断言关键字: {}".format(assert_key))
        print("接口名称: {}".format(interface_name))
        print("所属项目: {}".format(belong_project))
        print("所属模块: {}".format(belong_module))
        print("用例维护人: {}".format(maintainer))
        print("请求方法: {}".format(request_method))
        url = "{}{}".format(server_address, interface_name)
        print("接口地址: {}".format(url))
        code, request_data, error_msg = data_preprocess(global_key, str(request_data))
        try:
            res_data = request_process(url, request_method, json.loads(request_data))
            print("响应数据: {}".format(json.dumps(res_data.json(), ensure_ascii=False)))  # ensure_ascii：兼容中文
            result_flag, exception_info = assert_result(res_data, assert_key)
            if result_flag:
                print("用例【%s】执行成功！" % test_case)
                if extract_var.strip() != "None":
                    data_postprocess(global_key, json.dumps(res_data.json(), ensure_ascii=False), extract_var)
            else:
                print("用例【%s】执行失败！" % test_case)
        except Exception as e:
            print("接口请求异常，error: {}".format(traceback.format_exc()))

4）修改测试用例视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
from .models import Project, Module, TestCase, CaseSuite, SuiteCase, InterfaceServer
from .task import case_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            case_task(test_case_id_list, server_address)
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = Module.objects.get(id=int(module_id))
    test_cases = TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合菜单项
@login_required
def case_suite(request):
    case_suites = CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = CaseSuite.objects.get(id=suite_id)
    test_cases = SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

 

9. 用例执行结果展示

9.1 定义模型类

1）models.py 中增加 TestCaseExecuteResult 模型类，用于记录用例执行结果。

from django.db import models
from smart_selects.db_fields import GroupedForeignKey  # pip install django-smart-selects：后台级联选择
from django.contrib.auth.models import User


class Project(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('项目名称', max_length=50, unique=True, null=False)
    proj_owner = models.CharField('项目负责人', max_length=20, null=False)
    test_owner = models.CharField('测试负责人', max_length=20, null=False)
    dev_owner = models.CharField('开发负责人', max_length=20, null=False)
    desc = models.CharField('项目描述', max_length=100, null=True)
    create_time = models.DateTimeField('项目创建时间', auto_now_add=True)
    update_time = models.DateTimeField('项目更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '项目信息表'
        verbose_name_plural = '项目信息表'


class Module(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('模块名称', max_length=50, null=False)
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE)
    test_owner = models.CharField('测试负责人', max_length=50, null=False)
    desc = models.CharField('简要描述', max_length=100, null=True)
    create_time = models.DateTimeField('创建时间', auto_now_add=True)
    update_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '模块信息表'
        verbose_name_plural = '模块信息表'


class TestCase(models.Model):
    id = models.AutoField(primary_key=True)
    case_name = models.CharField('用例名称', max_length=50, null=False)  # 如 register
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE, verbose_name='所属项目')
    belong_module = GroupedForeignKey(Module, "belong_project", on_delete=models.CASCADE, verbose_name='所属模块')
    request_data = models.CharField('请求数据', max_length=1024, null=False, default='')
    uri = models.CharField('接口地址', max_length=1024, null=False, default='')
    assert_key = models.CharField('断言内容', max_length=1024, null=True)
    maintainer = models.CharField('编写人员', max_length=1024, null=False, default='')
    extract_var = models.CharField('提取变量表达式', max_length=1024, null=True)  # 示例：userid||userid": (\d+)
    request_method = models.CharField('请求方式', max_length=1024, null=True)
    status = models.IntegerField(null=True, help_text="0：表示有效，1：表示无效，用于软删除")
    created_time = models.DateTimeField('创建时间', auto_now_add=True)
    updated_time = models.DateTimeField('更新时间', auto_now=True, null=True)
    user = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name='责任人', null=True)

    def __str__(self):
        return self.case_name

    class Meta:
        verbose_name = '测试用例表'
        verbose_name_plural = '测试用例表'


class CaseSuite(models.Model):
    id = models.AutoField(primary_key=True)
    suite_desc = models.CharField('用例集合描述', max_length=100, blank=True, null=True)
    if_execute = models.IntegerField(verbose_name='是否执行', null=False, default=0, help_text='0：执行；1：不执行')
    test_case_model = models.CharField('测试执行模式', max_length=100, blank=True, null=True, help_text='data/keyword')
    creator = models.CharField(max_length=50, blank=True, null=True)
    create_time = models.DateTimeField('创建时间', auto_now=True)  # 创建时间-自动获取当前时间

    class Meta:
        verbose_name = "用例集合表"
        verbose_name_plural = '用例集合表'


class SuiteCase(models.Model):
    id = models.AutoField(primary_key=True)
    case_suite = models.ForeignKey(CaseSuite, on_delete=models.CASCADE, verbose_name='用例集合')
    test_case = models.ForeignKey(TestCase, on_delete=models.CASCADE, verbose_name='测试用例')
    status = models.IntegerField(verbose_name='是否有效', null=False, default=1, help_text='0：有效，1：无效')
    create_time = models.DateTimeField('创建时间', auto_now=True)  # 创建时间-自动获取当前时间


class InterfaceServer(models.Model):
    id = models.AutoField(primary_key=True)
    env = models.CharField('环境', max_length=50, null=False, default='')
    ip = models.CharField('ip', max_length=50, null=False, default='')
    port = models.CharField('端口', max_length=100, null=False, default='')
    remark = models.CharField('备注', max_length=100, null=True)
    create_time = models.DateTimeField('创建时间', auto_now_add=True)
    update_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.env

    class Meta:
        verbose_name = '接口地址配置表'
        verbose_name_plural = '接口地址配置表'


class TestCaseExecuteResult(models.Model):
    id = models.AutoField(primary_key=True)
    belong_test_case = GroupedForeignKey(TestCase, "belong_test_case", on_delete=models.CASCADE, verbose_name='所属用例')
    status = models.IntegerField(null=True, help_text="0：表示未执行，1：表示已执行")
    exception_info = models.CharField(max_length=2048, blank=True, null=True)
    request_data = models.CharField('请求体', max_length=1024, null=True)  # {"code": "00", "userid": 22889}
    response_data = models.CharField('响应字符串', max_length=1024, null=True)  # {"code": "00", "userid": 22889}
    execute_result = models.CharField('执行结果', max_length=1024, null=True)  # 成功/失败
    extract_var = models.CharField('关联参数', max_length=1024, null=True)  # 响应成功后提取变量
    last_time_response_data = models.CharField('上一次响应字符串', max_length=1024, null=True)  # {"code": "00", "userid": 22889}
    execute_total_time = models.CharField('执行耗时', max_length=1024, null=True)
    execute_start_time = models.CharField('执行开始时间', max_length=300, blank=True, null=True)
    execute_end_time = models.CharField('执行结束时间', max_length=300, blank=True, null=True)
    created_time = models.DateTimeField('创建时间', auto_now_add=True)
    updated_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return str(self.id)

    class Meta:
        verbose_name = '用例执行结果记录表'
        verbose_name_plural = '用例执行结果记录表'

2）数据迁移

python manage.py makemigrations
python manage.py migrate

9.2 修改用例执行封装函数，增加执行结果记录

修改应用目录下 task.py：

import time
import os
import traceback
import json
from . import models
from .utils.data_process import data_preprocess, assert_result, data_postprocess
from .utils.request_process import request_process


def case_task(test_case_id_list, server_address):
    global_key = 'case'+ str(int(time.time() * 100000))
    os.environ[global_key] = '{}'
    print()
    print("全局变量标识符【global_key】: {}".format(global_key))
    print("全局变量内容【os.environ[global_key]】: {}".format(os.environ[global_key]))
    for test_case_id in test_case_id_list:

        test_case = models.TestCase.objects.filter(id=int(test_case_id))[0]
        last_execute_record_data = models.TestCaseExecuteResult.objects.filter(
            belong_test_case_id=test_case_id).order_by('-id')
        if last_execute_record_data:
            last_time_execute_response_data = last_execute_record_data[0].response_data
        else:
            last_time_execute_response_data = ''
        print("上一次响应结果: {}".format(last_execute_record_data))
        print("上一次响应时间: {}".format(last_time_execute_response_data))
        execute_record = models.TestCaseExecuteResult.objects.create(belong_test_case=test_case)
        execute_record.last_time_response_data = last_time_execute_response_data
        # 获取当前用例上一次执行结果
        execute_record.save()

        test_case = models.TestCase.objects.filter(id=int(test_case_id))[0]
        print("\n######### 开始执行用例【{}】 #########".format(test_case))
        execute_start_time = time.time()  # 记录时间戳，便于计算总耗时（毫秒）
        execute_record.execute_start_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_start_time))

        request_data = test_case.request_data
        extract_var = test_case.extract_var
        assert_key = test_case.assert_key
        interface_name = test_case.uri
        belong_project = test_case.belong_project
        belong_module = test_case.belong_module
        maintainer = test_case.maintainer
        request_method = test_case.request_method
        print("初始请求数据: {}".format(request_data))
        print("关联参数: {}".format(extract_var))
        print("断言关键字: {}".format(assert_key))
        print("接口名称: {}".format(interface_name))
        print("所属项目: {}".format(belong_project))
        print("所属模块: {}".format(belong_module))
        print("用例维护人: {}".format(maintainer))
        print("请求方法: {}".format(request_method))
        url = "{}{}".format(server_address, interface_name)
        print("接口地址: {}".format(url))
        code, request_data, error_msg = data_preprocess(global_key, str(request_data))
        # 请求数据预处理异常，结束用例执行
        if code != 0:
            print("数据处理异常，error: {}".format(error_msg))
            execute_record.execute_result = "失败"
            execute_record.status = 1
            execute_record.exception_info = error_msg
            execute_end_time = time.time()
            execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_end_time))
            execute_record.execute_total_time = int(execute_end_time - execute_start_time) * 1000
            execute_record.save()
            return
        # 记录请求预处理结果
        else:
            execute_record.request_data = request_data
        # 调用接口
        try:
            res_data = request_process(url, request_method, json.loads(request_data))
            print("响应数据: {}".format(json.dumps(res_data.json(), ensure_ascii=False)))  # ensure_ascii：兼容中文
            result_flag, exception_info = assert_result(res_data, assert_key)
            # 结果记录保存
            if result_flag:
                print("用例【%s】执行成功！" % test_case)
                execute_record.execute_result = "成功"
                if extract_var.strip() != "None":
                    var_value = data_postprocess(global_key, json.dumps(res_data.json(), ensure_ascii=False), extract_var)
                    execute_record.extract_var = var_value
            else:
                print("用例【%s】执行失败！" % test_case)
                execute_record.execute_result = "失败"
                execute_record.exception_info = exception_info
            execute_record.response_data = json.dumps(res_data.json(), ensure_ascii=False)
            execute_record.status = 1
            execute_end_time = time.time()
            execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_end_time))
            print("执行结果结束时间: {}".format(execute_record.execute_end_time))
            execute_record.execute_total_time = int((execute_end_time - execute_start_time) * 1000)
            print("用例执行耗时: {}".format(execute_record.execute_total_time))
            execute_record.save()
        except Exception as e:
            print("接口请求异常，error: {}".format(traceback.format_exc()))
            execute_record.execute_result = "失败"
            execute_record.exception_info = traceback.format_exc()
            execute_record.status = 1
            execute_end_time = time.time()
            execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_end_time))
            print("执行结果结束时间: {}".format(execute_record.execute_end_time))
            execute_record.execute_total_time = int(execute_end_time - execute_start_time) * 1000
            print("用例执行耗时: {} 毫秒".format(execute_record.execute_total_time))
            execute_record.save()

前端执行测试用例，查看用例执行结果表数据：

9.3 定义路由 

在前面已经获取到用例结果数据并保存，下面处理一下用例结果展示。 

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('case_suite/', views.case_suite, name="case_suite"),
    re_path('add_case_in_suite/(?P<suite_id>[0-9]+)', views.add_case_in_suite, name="add_case_in_suite"),
    re_path('show_and_delete_case_in_suite/(?P<suite_id>[0-9]+)', views.show_and_delete_case_in_suite, name="show_and_delete_case_in_suite"),
    path('test_case_execute_record/', views.test_case_execute_record, name="test_case_execute_record"),
]

9.4 定义视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
from .models import Project, Module, TestCase, CaseSuite, SuiteCase, InterfaceServer, TestCaseExecuteResult
from .task import case_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            case_task(test_case_id_list, server_address)
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = Module.objects.get(id=int(module_id))
    test_cases = TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合菜单项
@login_required
def case_suite(request):
    case_suites = CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = CaseSuite.objects.get(id=suite_id)
    test_cases = SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


@login_required
def test_case_execute_record(request):
    test_case_execute_records = TestCaseExecuteResult.objects.filter().order_by('-id')
    return render(request, 'test_case_execute_records.html', {'test_case_execute_records': get_paginator(request, test_case_execute_records)})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

9.5 定义模板

1）新增”测试执行记录“模板文件：templates/test_case_execute_records.html

{% extends 'base.html' %}
{% load static %}
{% block title %}用例执行记录{% endblock %}
{% block content %}

<div class="table-responsive">
    <table class="table table-striped">
        <thead>
        <tr>
            <th width="4%">id</th>
            <th width="4%">名称</th>
            <th width="20%">请求数据</th>
            <th width="20%">执行返回结果</th>
            <th width="5%">操作</th>
            <th>断言内容</th>
            <th width="5%">执行结果</th>
            <th width="5%">异常信息</th>
            <th width="10%">请求后提取变量</th>
            <th width="8%">开始时间</th>
            <th width="8%">执行耗时(ms)</th>
        </tr>
        </thead>
        <tbody>

        {% for testrecord in test_case_execute_records %}
        <tr>
            <td>{{ testrecord.id }}</td>
            <td><a href="{% url 'test_case_detail' testrecord.belong_test_case.id%}" target="_blank">{{ testrecord.belong_test_case.case_name }}</a></td>
            <td>{{ testrecord.request_data }}</td>
            <td>{{ testrecord.response_data }}</td>
            <td><a href="" target="_blank">对比差异</a></td>
            <td>{{ testrecord.belong_test_case.assert_key }}</td>
            <td>{{ testrecord.execute_result|default_if_none:"" }}</td>
            {% if testrecord.exception_info %}
            <td><a href="" target="_blank">显示异常信息</a></td>
            {% else %}
            <td>无</td>
            {% endif %}

            <td>{{ testrecord.extract_var }}</td>
            <td>{{ testrecord.execute_start_time }}</td>
            <td>{{ testrecord.execute_total_time }}</td>
        </tr>
        {% endfor %}

        </tbody>
    </table>

    {# 实现分页标签的代码 #}
    {# 这里使用 bootstrap 渲染页面 #}
    <div id="pages" class="text-center">
        <nav>
            <ul class="pagination">
                <li class="step-links">
                    {% if test_case_execute_records.has_previous %}
                    <a class='active' href="?page={{ test_case_execute_records.previous_page_number }}">上一页</a>
                    {% endif %}

                    <span class="current">
                    第 {{ test_case_execute_records.number }} 页 / 共 {{ test_case_execute_records.paginator.num_pages }} 页</span>

                    {% if test_case_execute_records.has_next %}
                    <a class='active' href="?page={{ test_case_execute_records.next_page_number }}">下一页</a>
                    {% endif %}
                </li>
            </ul>
        </nav>
    </div>
</div>
{% endblock %}

2）修改 base.html：新增“用例执行结果”菜单项

<!DOCTYPE html>
<html lang="zh-CN">
{% load static %}
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
    <title>{% block title %}base{% endblock %}</title>

    <!-- Bootstrap -->
    <link href="{% static 'bootstrap/css/bootstrap.min.css' %}" rel="stylesheet">


    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    <script src="https://cdn.bootcss.com/html5shiv/3.7.3/html5shiv.min.js"></script>
    <script src="https://cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
    {% block css %}{% endblock %}
</head>
<body>
<nav class="navbar navbar-default">
    <div class="container-fluid">
        <!-- Brand and toggle get grouped for better mobile display -->
        <div class="navbar-header">
            <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#my-nav"
                    aria-expanded="false">
                <span class="sr-only">切换导航条</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>
            <a class="navbar-brand" href="/">自动化测试平台</a>
        </div>

        <div class="collapse navbar-collapse" id="my-nav">
            <ul class="nav navbar-nav">
                <li class="active"><a href="/project/">项目</a></li>
                <li class="active"><a href="/module/">模块</a></li>
                <li class="active"><a href="/test_case/">测试用例</a></li>
                <li class="active"><a href="/case_suite/">用例集合</a></li>
                <li class="active"><a href="/test_case_execute_record/">用例执行结果</a></li>
            </ul>
            <ul class="nav navbar-nav navbar-right">
                {% if request.user.is_authenticated %}
                <li><a href="#">当前在线：{{ request.user.username }}</a></li>
                <li><a href="/logout">登出</a></li>
                {% else %}
                <li><a href="/login">登录</a></li>

                {% endif %}
            </ul>
        </div><!-- /.navbar-collapse -->
    </div><!-- /.container-fluid -->
</nav>

{% block content %}{% endblock %}


<!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
<script src="{% static 'js/jquery-3.4.1.js' %}"></script>
<!-- Include all compiled plugins (below), or include individual files as needed -->
<script src="{% static 'bootstrap/js/bootstrap.min.js' %}"></script>
</body>
</html>

页面效果如下：

9.6 结果对比差异

在用例执行结果页面，可以看到在“操作”列，有“对比差异”链接，该功能用于对比当前用例上一次的执行结果与当前的执行结果，便于查看结果的差异。

由于在前面用例执行时，已经在结果记录环节获取到当前用例上一次的结果并记录到当前用例记录数据中，下面来处理一下这个页面的展示。

1） 定义路由

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('case_suite/', views.case_suite, name="case_suite"),
    re_path('add_case_in_suite/(?P<suite_id>[0-9]+)', views.add_case_in_suite, name="add_case_in_suite"),
    re_path('show_and_delete_case_in_suite/(?P<suite_id>[0-9]+)', views.show_and_delete_case_in_suite, name="show_and_delete_case_in_suite"),
    path('test_case_execute_record/', views.test_case_execute_record, name="test_case_execute_record"),
    re_path('case_result_diff/(?P<test_record_id>[0-9]+)', views.case_result_diff, name="case_result_diff"),
]

2）定义视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
import json
from .models import Project, Module, TestCase, CaseSuite, SuiteCase, InterfaceServer, TestCaseExecuteResult
from .task import case_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            case_task(test_case_id_list, server_address)
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = Module.objects.get(id=int(module_id))
    test_cases = TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合菜单项
@login_required
def case_suite(request):
    case_suites = CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = CaseSuite.objects.get(id=suite_id)
    test_cases = SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例执行结果菜单项
@login_required
def test_case_execute_record(request):
    test_case_execute_records = TestCaseExecuteResult.objects.filter().order_by('-id')
    return render(request, 'test_case_execute_records.html', {'test_case_execute_records': get_paginator(request, test_case_execute_records)})


# 用例执行结果-对比差异
@login_required
def diffCaseResponse(request, test_record_id):
    test_record_data = TestCaseExecuteResult.objects.get(id=test_record_id)
    print("用例执行结果记录: {}".format(test_record_data))
    present_response = test_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response), sort_keys=True, indent=4,
                                      ensure_ascii=False)  # 中文字符不转ascii编码
        print("当前响应结果: {}".format(present_response))
    last_time_execute_response = test_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True, indent=4,
                                                ensure_ascii=False)
    print("上一次响应结果: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

3）定义模板

新增 case_result_diff.html：

{% extends 'base.html' %}
{% load static %}
{% block title %}结果对比差异{% endblock %}

{% block content %}
            <table class="table table-striped">
              <thead>
                <tr>
                  <th width="50%">上次执行结果</th>
                  <th width="50%">本次执行结果</th>
                </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>
                            <div>
                                <pre style="height: 400px;">{{ last_time_execute_response | safe }}</pre>
                            </div>
                        </td>
                        <td>
                            <div><pre style="height: 400px;">{{ present_response | safe }}</pre></div>
                        </td>
                     </tr>
                </tbody>
            </table>

{% endblock %}

修改 test_case_execute_records.html：增加“对比差异”链接

{% extends 'base.html' %}
{% load static %}
{% block title %}用例执行记录{% endblock %}
{% block content %}

<div class="table-responsive">
    <table class="table table-striped">
        <thead>
        <tr>
            <th width="4%">id</th>
            <th width="4%">名称</th>
            <th width="20%">请求数据</th>
            <th width="20%">执行返回结果</th>
            <th width="5%">操作</th>
            <th>断言内容</th>
            <th width="5%">执行结果</th>
            <th width="5%">异常信息</th>
            <th width="10%">请求后提取变量</th>
            <th width="8%">开始时间</th>
            <th width="8%">执行耗时(ms)</th>
        </tr>
        </thead>
        <tbody>

        {% for testrecord in test_case_execute_records %}
        <tr>
            <td>{{ testrecord.id }}</td>
            <td><a href="{% url 'test_case_detail' testrecord.belong_test_case.id%}" target="_blank">{{ testrecord.belong_test_case.case_name }}</a></td>
            <td>{{ testrecord.request_data }}</td>
            <td>{{ testrecord.response_data }}</td>
            <td><a href="{% url 'case_result_diff' testrecord.id %}" target="_blank">对比差异</a></td>
            <td>{{ testrecord.belong_test_case.assert_key }}</td>
            <td>{{ testrecord.execute_result|default_if_none:"" }}</td>
            {% if testrecord.exception_info %}
            <td><a href="" target="_blank">显示异常信息</a></td>
            {% else %}
            <td>无</td>
            {% endif %}

            <td>{{ testrecord.extract_var }}</td>
            <td>{{ testrecord.execute_start_time }}</td>
            <td>{{ testrecord.execute_total_time }}</td>
        </tr>
        {% endfor %}

        </tbody>
    </table>

    {# 实现分页标签的代码 #}
    {# 这里使用 bootstrap 渲染页面 #}
    <div id="pages" class="text-center">
        <nav>
            <ul class="pagination">
                <li class="step-links">
                    {% if test_case_execute_records.has_previous %}
                    <a class='active' href="?page={{ test_case_execute_records.previous_page_number }}">上一页</a>
                    {% endif %}

                    <span class="current">
                    第 {{ test_case_execute_records.number }} 页 / 共 {{ test_case_execute_records.paginator.num_pages }} 页</span>

                    {% if test_case_execute_records.has_next %}
                    <a class='active' href="?page={{ test_case_execute_records.next_page_number }}">下一页</a>
                    {% endif %}
                </li>
            </ul>
        </nav>
    </div>
</div>
{% endblock %}

9.7 异常信息展示

1）定义路由 

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('case_suite/', views.case_suite, name="case_suite"),
    re_path('add_case_in_suite/(?P<suite_id>[0-9]+)', views.add_case_in_suite, name="add_case_in_suite"),
    re_path('show_and_delete_case_in_suite/(?P<suite_id>[0-9]+)', views.show_and_delete_case_in_suite, name="show_and_delete_case_in_suite"),
    path('test_case_execute_record/', views.test_case_execute_record, name="test_case_execute_record"),
    re_path('case_result_diff/(?P<test_record_id>[0-9]+)', views.case_result_diff, name="case_result_diff"),
    re_path('show_exception/(?P<execute_id>[0-9]+)$', views.show_exception, name="show_exception"),
]

2）定义视图函数 

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
import json
from .models import Project, Module, TestCase, CaseSuite, SuiteCase, InterfaceServer, TestCaseExecuteResult
from .task import case_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            case_task(test_case_id_list, server_address)
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = Module.objects.get(id=int(module_id))
    test_cases = TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合菜单项
@login_required
def case_suite(request):
    case_suites = CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = CaseSuite.objects.get(id=suite_id)
    test_cases = SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例执行结果菜单项
@login_required
def test_case_execute_record(request):
    test_case_execute_records = TestCaseExecuteResult.objects.filter().order_by('-id')
    return render(request, 'test_case_execute_records.html', {'test_case_execute_records': get_paginator(request, test_case_execute_records)})


# 用例执行结果-对比差异
@login_required
def case_result_diff(request, test_record_id):
    test_record_data = TestCaseExecuteResult.objects.get(id=test_record_id)
    print("用例执行结果记录: {}".format(test_record_data))
    present_response = test_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response), sort_keys=True, indent=4,
                                      ensure_ascii=False)  # 中文字符不转ascii编码
        print("当前响应结果: {}".format(present_response))
    last_time_execute_response = test_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True, indent=4,
                                                ensure_ascii=False)
    print("上一次响应结果: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例执行结果-异常信息展示
@login_required
def show_exception(request, execute_id):
    test_record = TestCaseExecuteResult.objects.get(id=execute_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

3）定义模板

新增异常信息展示模板：show_exception.html

{% extends 'base.html' %}
{% load static %}
{% block title %}异常信息{% endblock %}
{% block content %}

<p style="margin-left: 10px;">异常信息如下：</p>
<p style="margin-left: 10px; width: 90%">{{ exception_info|default_if_none:"" }}</p>

{% endblock %}

修改用例执行记录模板 test_case_execute_records.html：增加异常信息展示链接

{% extends 'base.html' %}
{% load static %}
{% block title %}用例执行记录{% endblock %}
{% block content %}

<div class="table-responsive">
    <table class="table table-striped">
        <thead>
        <tr>
            <th width="4%">id</th>
            <th width="4%">名称</th>
            <th width="20%">请求数据</th>
            <th width="20%">执行返回结果</th>
            <th width="5%">操作</th>
            <th>断言内容</th>
            <th width="5%">执行结果</th>
            <th width="5%">异常信息</th>
            <th width="10%">请求后提取变量</th>
            <th width="8%">开始时间</th>
            <th width="8%">执行耗时(ms)</th>
        </tr>
        </thead>
        <tbody>

        {% for testrecord in test_case_execute_records %}
        <tr>
            <td>{{ testrecord.id }}</td>
            <td><a href="{% url 'test_case_detail' testrecord.belong_test_case.id%}" target="_blank">{{ testrecord.belong_test_case.case_name }}</a></td>
            <td>{{ testrecord.request_data }}</td>
            <td>{{ testrecord.response_data }}</td>
            <td><a href="{% url 'case_result_diff' testrecord.id %}" target="_blank">对比差异</a></td>
            <td>{{ testrecord.belong_test_case.assert_key }}</td>

            {% ifequal testrecord.execute_result '成功' %}
            <td bgcolor='green'>{{ testrecord.execute_result}}</td>
            {% else %}
            <td bgcolor='red'>{{ testrecord.execute_result}}</td>
            {% endifequal %}

            {% if testrecord.exception_info %}
            <td><a href="{% url 'show_exception' testrecord.id %}" target="_blank">显示异常信息</a></td>
            {% else %}
            <td>无</td>
            {% endif %}

            <td>{{ testrecord.extract_var }}</td>
            <td>{{ testrecord.execute_start_time }}</td>
            <td>{{ testrecord.execute_total_time }}</td>
        </tr>
        {% endfor %}

        </tbody>
    </table>

    {# 实现分页标签的代码 #}
    {# 这里使用 bootstrap 渲染页面 #}
    <div id="pages" class="text-center">
        <nav>
            <ul class="pagination">
                <li class="step-links">
                    {% if test_case_execute_records.has_previous %}
                    <a class='active' href="?page={{ test_case_execute_records.previous_page_number }}">上一页</a>
                    {% endif %}

                    <span class="current">
                    第 {{ test_case_execute_records.number }} 页 / 共 {{ test_case_execute_records.paginator.num_pages }} 页</span>

                    {% if test_case_execute_records.has_next %}
                    <a class='active' href="?page={{ test_case_execute_records.next_page_number }}">下一页</a>
                    {% endif %}
                </li>
            </ul>
        </nav>
    </div>
</div>
{% endblock %}

  

10. 测试集合执行

在前面的测试用例执行步骤，我们已经把请求数据处理、接口请求、断言、变量提取等环节做了处理。那么测试集合的执行也可以复用前面的逻辑，前端在提交测试集合到后端时，后端获取到集合中包含的用例 ，调用用例执行的方法即可，然后记录测试集合执行相关的结果记录。

10.1 定义模型

models.py：

from django.db import models
from smart_selects.db_fields import GroupedForeignKey  # pip install django-smart-selects：后台级联选择
from django.contrib.auth.models import User


# 项目
class Project(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('项目名称', max_length=50, unique=True, null=False)
    proj_owner = models.CharField('项目负责人', max_length=20, null=False)
    test_owner = models.CharField('测试负责人', max_length=20, null=False)
    dev_owner = models.CharField('开发负责人', max_length=20, null=False)
    desc = models.CharField('项目描述', max_length=100, null=True)
    create_time = models.DateTimeField('项目创建时间', auto_now_add=True)
    update_time = models.DateTimeField('项目更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '项目信息表'
        verbose_name_plural = '项目信息表'


# 模块
class Module(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField('模块名称', max_length=50, null=False)
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE)
    test_owner = models.CharField('测试负责人', max_length=50, null=False)
    desc = models.CharField('简要描述', max_length=100, null=True)
    create_time = models.DateTimeField('创建时间', auto_now_add=True)
    update_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '模块信息表'
        verbose_name_plural = '模块信息表'


# 测试用例
class TestCase(models.Model):
    id = models.AutoField(primary_key=True)
    case_name = models.CharField('用例名称', max_length=50, null=False)  # 如 register
    belong_project = models.ForeignKey(Project, on_delete=models.CASCADE, verbose_name='所属项目')
    belong_module = GroupedForeignKey(Module, "belong_project", on_delete=models.CASCADE, verbose_name='所属模块')
    request_data = models.CharField('请求数据', max_length=1024, null=False, default='')
    uri = models.CharField('接口地址', max_length=1024, null=False, default='')
    assert_key = models.CharField('断言内容', max_length=1024, null=True)
    maintainer = models.CharField('编写人员', max_length=1024, null=False, default='')
    extract_var = models.CharField('提取变量表达式', max_length=1024, null=True)  # 示例：userid||userid": (\d+)
    request_method = models.CharField('请求方式', max_length=1024, null=True)
    status = models.IntegerField(null=True, help_text="0：表示有效，1：表示无效，用于软删除")
    created_time = models.DateTimeField('创建时间', auto_now_add=True)
    updated_time = models.DateTimeField('更新时间', auto_now=True, null=True)
    user = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name='责任人', null=True)

    def __str__(self):
        return self.case_name

    class Meta:
        verbose_name = '测试用例表'
        verbose_name_plural = '测试用例表'


# 用例集合
class CaseSuite(models.Model):
    id = models.AutoField(primary_key=True)
    suite_desc = models.CharField('用例集合描述', max_length=100, blank=True, null=True)
    if_execute = models.IntegerField(verbose_name='是否执行', null=False, default=0, help_text='0：执行；1：不执行')
    test_case_model = models.CharField('测试执行模式', max_length=100, blank=True, null=True, help_text='data/keyword')
    creator = models.CharField(max_length=50, blank=True, null=True)
    create_time = models.DateTimeField('创建时间', auto_now=True)  # 创建时间-自动获取当前时间

    class Meta:
        verbose_name = "用例集合表"
        verbose_name_plural = '用例集合表'


# 用例集合关联用例
class SuiteCase(models.Model):
    id = models.AutoField(primary_key=True)
    case_suite = models.ForeignKey(CaseSuite, on_delete=models.CASCADE, verbose_name='用例集合')
    test_case = models.ForeignKey(TestCase, on_delete=models.CASCADE, verbose_name='测试用例')
    status = models.IntegerField(verbose_name='是否有效', null=False, default=1, help_text='0：有效，1：无效')
    create_time = models.DateTimeField('创建时间', auto_now=True)  # 创建时间-自动获取当前时间


# 接口服务器配置
class InterfaceServer(models.Model):
    id = models.AutoField(primary_key=True)
    env = models.CharField('环境', max_length=50, null=False, default='')
    ip = models.CharField('ip', max_length=50, null=False, default='')
    port = models.CharField('端口', max_length=100, null=False, default='')
    remark = models.CharField('备注', max_length=100, null=True)
    create_time = models.DateTimeField('创建时间', auto_now_add=True)
    update_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return self.env

    class Meta:
        verbose_name = '接口地址配置表'
        verbose_name_plural = '接口地址配置表'


# 测试用例执行记录
class TestCaseExecuteResult(models.Model):
    id = models.AutoField(primary_key=True)
    belong_test_case = GroupedForeignKey(TestCase, "belong_test_case", on_delete=models.CASCADE, verbose_name='所属用例')
    status = models.IntegerField(null=True, help_text="0：表示未执行，1：表示已执行")
    exception_info = models.CharField(max_length=2048, blank=True, null=True)
    request_data = models.CharField('请求体', max_length=1024, null=True)  # {"code": "00", "userid": 22889}
    response_data = models.CharField('响应字符串', max_length=1024, null=True)  # {"code": "00", "userid": 22889}
    execute_result = models.CharField('执行结果', max_length=1024, null=True)  # 成功/失败
    extract_var = models.CharField('关联参数', max_length=1024, null=True)  # 响应成功后提取变量
    last_time_response_data = models.CharField('上一次响应字符串', max_length=1024, null=True)  # {"code": "00", "userid": 22889}
    execute_total_time = models.CharField('执行耗时', max_length=1024, null=True)
    execute_start_time = models.CharField('执行开始时间', max_length=300, blank=True, null=True)
    execute_end_time = models.CharField('执行结束时间', max_length=300, blank=True, null=True)
    created_time = models.DateTimeField('创建时间', auto_now_add=True)
    updated_time = models.DateTimeField('更新时间', auto_now=True, null=True)

    def __str__(self):
        return str(self.id)

    class Meta:
        verbose_name = '用例执行结果记录表'
        verbose_name_plural = '用例执行结果记录表'


# 用例集合的执行记录
class CaseSuiteExecuteRecord(models.Model):
    id = models.AutoField(primary_key=True)
    case_suite = models.ForeignKey(CaseSuite, on_delete=models.CASCADE, verbose_name='测试集合')
    run_time_interval = models.IntegerField(verbose_name='延迟时间', null=True, default=0)
    status = models.IntegerField(verbose_name='执行状态', null=True, default=0)
    test_result = models.CharField(max_length=50, blank=True, null=True)
    creator = models.CharField(max_length=50, blank=True, null=True)
    create_time = models.DateTimeField('创建时间', auto_now=True)   # 创建时间-自动获取当前时间
    execute_start_time = models.CharField('执行开始时间', max_length=300, blank=True, null=True)


# 用例集合下的用例执行记录
class CaseSuiteTestCaseExecuteRecord(models.Model):
    id = models.AutoField(primary_key=True)
    case_suite_record = models.ForeignKey(CaseSuiteExecuteRecord, on_delete=models.CASCADE, verbose_name='测试集合执行记录')
    test_case = models.ForeignKey(TestCase, on_delete=models.CASCADE, verbose_name='测试用例')
    status = models.IntegerField(verbose_name='执行状态', null=True, default=0)
    exception_info = models.CharField(max_length=2048, blank=True, null=True)
    request_data = models.CharField('请求体', max_length=1024, null=True)  # {"code": "00", "userid": 22889}
    response_data = models.CharField('响应字符串', max_length=1024, null=True)  # {"code": "00", "userid": 22889}
    execute_result = models.CharField('执行结果', max_length=1024, null=True)  # 成功/失败
    extract_var = models.CharField('关联参数', max_length=1024, null=True)  # 响应成功后提取变量
    last_time_response_data = models.CharField('上一次响应字符串', max_length=1024,
                                               null=True)  # {"code": "00", "userid": 22889}
    execute_total_time = models.CharField('执行耗时', max_length=1024, null=True)
    execute_start_time = models.CharField('执行开始时间', max_length=300, blank=True, null=True)
    execute_end_time = models.CharField('执行结束时间', max_length=300, blank=True, null=True)

执行数据迁移：

python manage.py makemigrations
python manage.py migrate

10.2 修改模板 

1）修改 case_suite.html 模板，增加提交测试集合相关组件。

{% extends 'base.html' %}
{% load static %}
{% block title %}用例集合{% endblock %}
{% block content %}
<script>
    //页面加载的时候,所有的复选框都是未选中的状态
    function checkOrCancelAll() {
        var all_check = document.getElementById("all_check");  // 1.获取all的元素对象
        var all_check = all_check.checked;  // 2.获取选中状态
        // 3.若checked=true,将所有的复选框选中,checked=false,将所有的复选框取消
        var allCheck = document.getElementsByName("case_suite_list");  
        // 4.循环遍历取出每一个复选框中的元素
        if (all_check)//全选
        {
            for (var i = 0; i < allCheck.length; i++) {
                //设置复选框的选中状态
                allCheck[i].checked = true;
            }
        } else//取消全选
        {
            for (var i = 0; i < allCheck.length; i++) {
                allCheck[i].checked = false;
            }
        }
    }
    function ischecked() {
        // 3.若checked=true,将所有的复选框选中,checked=false,将所有的复选框取消
        var allCheck = document.getElementsByName("case_suite_list");
        for (var i = 0; i < allCheck.length; i++) {

            if (allCheck[i].checked == true) {
                alert("所需执行的测试集合提交成功！");
                return true
            }
        }
        alert("请选择要执行的测试集合！")
        return false
    }
</script>

<form action="" method="POST">
    {% csrf_token %}
    <span style="margin-left: 5px;">延迟执行的时间（单位：秒）:</span>
    <input type="text" style="width: 70px; margin-left: 5px; margin-right: 10px;" placeholder="请输入" name="delay_time"/>
    <span style="margin-left: 5px;">运行环境：</span>
    <select name="env">
        <option selected value="dev">dev</option>
        <option value="prod">prod</option>
    </select>
    <input style="margin-left: 10px;" type="submit" id="all_check1" value='运行测试集合' onclick="return ischecked()"/>

    <div class="table-responsive">
        <table class="table table-striped">
            <thead>
            <tr>
                <th><input type="checkbox" id="all_check" onclick="checkOrCancelAll();"/>全选</th>
                <th>id</th>
                <th>测试集合名称</th>
                <th>创建者</th>
                <th>创建时间</th>
                <th>查看/删除测试用例</th>
                <th>添加测试用例</th>
                <th>用例集合执行结果</th>
            </tr>
            </thead>
            <tbody>

            {% for case_suite in case_suites %}
            <tr>
                <td><input type="checkbox" value="{{ case_suite.id }}" name="case_suite_list"></td>
                <td>{{ case_suite.id }}</td>
                <td>{{ case_suite.suite_desc }}</td>
                <td>{{ case_suite.creator }}</td>
                <td>{{ case_suite.create_time|date:"Y-n-d H:i" }}</td>
                <td><a href="{% url 'show_and_delete_case_in_suite' case_suite.id %}">查看/删除测试用例</a></td>
                <td><a href="{% url 'add_case_in_suite' case_suite.id %}">添加测试用例</a></td>
                <td><a href="">查看用例集合执行结果</a></td>
            </tr>
            {% endfor %}
            </tbody>
        </table>
    </div>
</form>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if case_suites.has_previous %}
                <a class='active' href="?page={{ case_suites.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ case_suites.number }} 页 / 共 {{ case_suites.paginator.num_pages }} 页</span>

                {% if case_suites.has_next %}
                <a class='active' href="?page={{ case_suites.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

10.3 后端接收用例集合并处理

1）在应用 task.py 中增加用例集合执行的任务函数：

import time
import os
import traceback
import json
from . import models
from .utils.data_process import data_preprocess, assert_result, data_postprocess
from .utils.request_process import request_process


# 测试用例执行
def case_task(test_case_id_list, server_address):
    global_key = 'case'+ str(int(time.time() * 100000))
    os.environ[global_key] = '{}'
    print()
    print("全局变量标识符【global_key】: {}".format(global_key))
    print("全局变量内容【os.environ[global_key]】: {}".format(os.environ[global_key]))
    for test_case_id in test_case_id_list:

        test_case = models.TestCase.objects.filter(id=int(test_case_id))[0]
        last_execute_record_data = models.TestCaseExecuteResult.objects.filter(
            belong_test_case_id=test_case_id).order_by('-id')
        if last_execute_record_data:
            last_time_execute_response_data = last_execute_record_data[0].response_data
        else:
            last_time_execute_response_data = ''
        print("上一次响应结果: {}".format(last_execute_record_data))
        print("上一次响应时间: {}".format(last_time_execute_response_data))
        execute_record = models.TestCaseExecuteResult.objects.create(belong_test_case=test_case)
        execute_record.last_time_response_data = last_time_execute_response_data
        # 获取当前用例上一次执行结果
        execute_record.save()

        test_case = models.TestCase.objects.filter(id=int(test_case_id))[0]
        print("\n######### 开始执行用例【{}】 #########".format(test_case))
        execute_start_time = time.time()  # 记录时间戳，便于计算总耗时（毫秒）
        execute_record.execute_start_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_start_time))

        request_data = test_case.request_data
        extract_var = test_case.extract_var
        assert_key = test_case.assert_key
        interface_name = test_case.uri
        belong_project = test_case.belong_project
        belong_module = test_case.belong_module
        maintainer = test_case.maintainer
        request_method = test_case.request_method
        print("初始请求数据: {}".format(request_data))
        print("关联参数: {}".format(extract_var))
        print("断言关键字: {}".format(assert_key))
        print("接口名称: {}".format(interface_name))
        print("所属项目: {}".format(belong_project))
        print("所属模块: {}".format(belong_module))
        print("用例维护人: {}".format(maintainer))
        print("请求方法: {}".format(request_method))
        url = "{}{}".format(server_address, interface_name)
        print("接口地址: {}".format(url))
        code, request_data, error_msg = data_preprocess(global_key, str(request_data))
        # 请求数据预处理异常，结束用例执行
        if code != 0:
            print("数据处理异常，error: {}".format(error_msg))
            execute_record.execute_result = "失败"
            execute_record.status = 1
            execute_record.exception_info = error_msg
            execute_end_time = time.time()
            execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_end_time))
            execute_record.execute_total_time = int(execute_end_time - execute_start_time) * 1000
            execute_record.save()
            return
        # 记录请求预处理结果
        else:
            execute_record.request_data = request_data
        # 调用接口
        try:
            res_data = request_process(url, request_method, json.loads(request_data))
            print("响应数据: {}".format(json.dumps(res_data.json(), ensure_ascii=False)))  # ensure_ascii：兼容中文
            result_flag, exception_info = assert_result(res_data, assert_key)
            # 结果记录保存
            if result_flag:
                print("用例【%s】执行成功！" % test_case)
                execute_record.execute_result = "成功"
                if extract_var.strip() != "None":
                    var_value = data_postprocess(global_key, json.dumps(res_data.json(), ensure_ascii=False), extract_var)
                    execute_record.extract_var = var_value
            else:
                print("用例【%s】执行失败！" % test_case)
                execute_record.execute_result = "失败"
                execute_record.exception_info = exception_info
            execute_record.response_data = json.dumps(res_data.json(), ensure_ascii=False)
            execute_record.status = 1
            execute_end_time = time.time()
            execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_end_time))
            print("执行结果结束时间: {}".format(execute_record.execute_end_time))
            execute_record.execute_total_time = int((execute_end_time - execute_start_time) * 1000)
            print("用例执行耗时: {}".format(execute_record.execute_total_time))
            execute_record.save()
        except Exception as e:
            print("接口请求异常，error: {}".format(traceback.format_exc()))
            execute_record.execute_result = "失败"
            execute_record.exception_info = traceback.format_exc()
            execute_record.status = 1
            execute_end_time = time.time()
            execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_end_time))
            print("执行结果结束时间: {}".format(execute_record.execute_end_time))
            execute_record.execute_total_time = int(execute_end_time - execute_start_time) * 1000
            print("用例执行耗时: {} 毫秒".format(execute_record.execute_total_time))
            execute_record.save()


# 用例集合执行
def suite_task(case_suite_record, case_suite, server_address):
    global_key = case_suite.suite_desc + str(int(time.time() * 100000))
    # global_vars = {"{}".format(global_key): {}}
    os.environ[global_key] = '{}'
    print("global_key: {}".format(global_key))
    print("os.environ[global_key]: {}".format(os.environ[global_key]))
    case_suite_test_cases = models.SuiteCase.objects.filter(case_suite=case_suite).order_by('id')
    print("用例集合的测试用例列表: {}".format(case_suite_test_cases))
    case_suite_record.test_result = "成功"
    case_suite_record.execute_start_time = time.strftime("%Y-%m-%d %H:%M:%S")

    for case_suite_test_case in case_suite_test_cases:
        test_case = case_suite_test_case.test_case
        print("\n######### 开始执行用例【{}】 #########".format(test_case))
        last_execute_record_data = models.CaseSuiteTestCaseExecuteRecord.objects.filter(
            test_case_id=test_case.id).order_by('-id')
        if last_execute_record_data:
            last_time_execute_response_data = last_execute_record_data[0].response_data
        else:
            last_time_execute_response_data = ''
        print("上一次响应结果: {}".format(last_execute_record_data))
        print("上一次响应时间: {}".format(last_time_execute_response_data))
        suite_case_execute_record = models.CaseSuiteTestCaseExecuteRecord.objects.create(case_suite_record=case_suite_record,
                                                                                  test_case=test_case)
        execute_start_time = time.time()  # 记录时间戳，便于计算总耗时（毫秒）
        suite_case_execute_record.execute_start_time = time.strftime("%Y-%m-%d %H:%M:%S",
                                                                     time.localtime(execute_start_time))
        print("用例集合开始执行时间: {}".format(suite_case_execute_record.execute_start_time))
        suite_case_execute_record.last_time_response_data = last_time_execute_response_data
        suite_case_execute_record.save()
        request_data = test_case.request_data
        extract_var = test_case.extract_var
        assert_key = test_case.assert_key
        interface_name = test_case.uri
        belong_project = test_case.belong_project
        belong_module = test_case.belong_module
        maintainer = test_case.maintainer
        request_method = test_case.request_method
        print("初始请求数据: {}".format(request_data))
        print("关联参数: {}".format(extract_var))
        print("断言关键字: {}".format(assert_key))
        print("接口名称: {}".format(interface_name))
        print("所属项目: {}".format(belong_project))
        print("所属模块: {}".format(belong_module))
        print("用例维护人: {}".format(maintainer))
        print("请求方法: {}".format(request_method))
        url = "{}{}".format(server_address, interface_name)
        print("接口地址: {}".format(url))
        # 请求数据预处理
        code, request_data, error_msg = data_preprocess(global_key, str(request_data))
        # 请求数据预处理异常，结束用例执行
        if code != 0:
            print("数据处理异常，error: {}".format(error_msg))
            suite_case_execute_record.execute_result = "失败"
            suite_case_execute_record.status = 1
            suite_case_execute_record.exception_info = error_msg
            execute_end_time = time.time()
            suite_case_execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S",
                                                                       time.localtime(execute_end_time))
            suite_case_execute_record.execute_total_time = int(execute_end_time - execute_start_time) * 1000
            suite_case_execute_record.save()
            case_suite_record.test_result = "失败"
        # 记录请求预处理的结果
        suite_case_execute_record.request_data = request_data
        try:
            # 调用接口
            res_data = request_process(url, request_method, json.loads(request_data))
            print("响应数据: {}".format(json.dumps(res_data.json(), ensure_ascii=False)))

            result_flag, exception_info = assert_result(res_data, assert_key)
            # 结果记录保存
            if result_flag:
                print("用例【%s】执行成功！" % test_case)
                suite_case_execute_record.execute_result = "成功"
                if extract_var.strip() != "None":
                    var_value = data_postprocess(global_key, json.dumps(res_data.json(), ensure_ascii=False),
                                                 extract_var)
                    suite_case_execute_record.extract_var = var_value
            else:
                print("用例【%s】执行失败！" % test_case)
                suite_case_execute_record.execute_result = "失败"
                suite_case_execute_record.exception_info = exception_info
                case_suite_record.test_result = "失败"
            suite_case_execute_record.response_data = json.dumps(res_data.json(), ensure_ascii=False)
            suite_case_execute_record.status = 1
            execute_end_time = time.time()
            suite_case_execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S",
                                                                       time.localtime(execute_end_time))
            suite_case_execute_record.execute_total_time = int((execute_end_time - execute_start_time) * 1000)
            print("用例执行耗时: {} 毫秒".format(
                suite_case_execute_record.execute_total_time))
            suite_case_execute_record.save()
        except Exception as e:
            print("接口请求异常，error: {}".format(e))
            suite_case_execute_record.execute_result = "失败"
            suite_case_execute_record.exception_info = traceback.format_exc()
            suite_case_execute_record.status = 1
            execute_end_time = time.time()
            suite_case_execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S",
                                                                       time.localtime(execute_end_time))
            suite_case_execute_record.execute_total_time = int(execute_end_time - execute_start_time) * 1000
            print("用例集合执行总耗时: {} 毫秒".format(suite_case_execute_record.execute_total_time))
            suite_case_execute_record.save()
            case_suite_record.test_result = "失败"

    case_suite_record.status = 1  # 执行完毕
    case_suite_record.save()

2）修改视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
import json
from .models import Project, Module, TestCase, CaseSuite, SuiteCase, InterfaceServer, TestCaseExecuteResult, CaseSuiteExecuteRecord
from .task import case_task, suite_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            case_task(test_case_id_list, server_address)
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = Module.objects.get(id=int(module_id))
    test_cases = TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合菜单项
@login_required
def case_suite(request):
    if request.method == "POST":
        count_down_time = 0
        if request.POST['delay_time']:
            print("输入的延迟时间是: {}".format(request.POST['delay_time']))
            try:
                count_down_time = int(request.POST['delay_time'])
            except:
                print("输入的延迟时间是非数字！")
        else:
            print("没有输入延迟时间")
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        case_suite_list = request.POST.getlist('case_suite_list')
        if case_suite_list:
            print("所需执行的用例集合列表：", case_suite_list)
            for suite_id in case_suite_list:
                test_suite = CaseSuite.objects.get(id=int(suite_id))
                print("所需执行的用例集合: {}".format(test_suite))
                username = request.user.username
                test_suite_record = CaseSuiteExecuteRecord.objects.create(case_suite=test_suite,
                                                                               run_time_interval=count_down_time,
                                                                               creator=username)
                suite_task(test_suite_record, test_suite, server_address)
        else:
            print("运行测试集合用例失败")
            return HttpResponse("运行的测试集合为空，请选择测试集合后再运行！")
    case_suites = CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = CaseSuite.objects.get(id=suite_id)
    test_cases = SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = TestCase.objects.get(id=int(test_case))
                SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例执行结果菜单项
@login_required
def test_case_execute_record(request):
    test_case_execute_records = TestCaseExecuteResult.objects.filter().order_by('-id')
    return render(request, 'test_case_execute_records.html', {'test_case_execute_records': get_paginator(request, test_case_execute_records)})


# 用例执行结果-对比差异
@login_required
def case_result_diff(request, test_record_id):
    test_record_data = TestCaseExecuteResult.objects.get(id=test_record_id)
    print("用例执行结果记录: {}".format(test_record_data))
    present_response = test_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response), sort_keys=True, indent=4,
                                      ensure_ascii=False)  # 中文字符不转ascii编码
        print("当前响应结果: {}".format(present_response))
    last_time_execute_response = test_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True, indent=4,
                                                ensure_ascii=False)
    print("上一次响应结果: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例执行结果-异常信息展示
@login_required
def show_exception(request, execute_id):
    test_record = TestCaseExecuteResult.objects.get(id=execute_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

前端页面勾选测试集合，提交运行，生成表数据如下所示：

  

11. 用例集合执行结果展示

11.1 定义路由

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('case_suite/', views.case_suite, name="case_suite"),
    re_path('add_case_in_suite/(?P<suite_id>[0-9]+)', views.add_case_in_suite, name="add_case_in_suite"),
    re_path('show_and_delete_case_in_suite/(?P<suite_id>[0-9]+)', views.show_and_delete_case_in_suite, name="show_and_delete_case_in_suite"),
    path('test_case_execute_record/', views.test_case_execute_record, name="test_case_execute_record"),
    re_path('case_result_diff/(?P<test_record_id>[0-9]+)', views.case_result_diff, name="case_result_diff"),
    re_path('show_exception/(?P<execute_id>[0-9]+)$', views.show_exception, name="show_exception"),
    path('case_suite_execute_record/', views.case_suite_execute_record, name="case_suite_execute_record"),
]

11.2 定义视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
import json
from . import models
from .task import case_task, suite_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目-菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = models.Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块-菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = models.Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = models.Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = models.Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = models.InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例-菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = models.TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            case_task(test_case_id_list, server_address)
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = models.TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = models.TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = models.Module.objects.get(id=int(module_id))
    test_cases = models.TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合-菜单项
@login_required
def case_suite(request):
    if request.method == "POST":
        count_down_time = 0
        if request.POST['delay_time']:
            print("输入的延迟时间是: {}".format(request.POST['delay_time']))
            try:
                count_down_time = int(request.POST['delay_time'])
            except:
                print("输入的延迟时间是非数字！")
        else:
            print("没有输入延迟时间")
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        case_suite_list = request.POST.getlist('case_suite_list')
        if case_suite_list:
            print("所需执行的用例集合列表：", case_suite_list)
            for suite_id in case_suite_list:
                test_suite = models.CaseSuite.objects.get(id=int(suite_id))
                print("所需执行的用例集合: {}".format(test_suite))
                username = request.user.username
                test_suite_record = models.CaseSuiteExecuteRecord.objects.create(case_suite=test_suite,
                                                                               run_time_interval=count_down_time,
                                                                               creator=username)
                suite_task(test_suite_record, test_suite, server_address)
        else:
            print("运行测试集合用例失败")
            return HttpResponse("运行的测试集合为空，请选择测试集合后再运行！")
    case_suites = models.CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = models.TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                models.SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    test_cases = models.SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                models.SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例执行结果-菜单项
@login_required
def test_case_execute_record(request):
    test_case_execute_records = models.TestCaseExecuteResult.objects.filter().order_by('-id')
    return render(request, 'test_case_execute_records.html', {'test_case_execute_records': 
                                                                  get_paginator(request, test_case_execute_records)})


# 用例执行结果-对比差异
@login_required
def case_result_diff(request, test_record_id):
    test_record_data = models.TestCaseExecuteResult.objects.get(id=test_record_id)
    print("用例执行结果记录: {}".format(test_record_data))
    present_response = test_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response), sort_keys=True, indent=4,
                                      ensure_ascii=False)  # 中文字符不转ascii编码
        print("当前响应结果: {}".format(present_response))
    last_time_execute_response = test_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True, indent=4,
                                                ensure_ascii=False)
    print("上一次响应结果: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例执行结果-异常信息展示
@login_required
def show_exception(request, execute_id):
    test_record = models.TestCaseExecuteResult.objects.get(id=execute_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果-菜单项
@login_required
def case_suite_execute_record(request):
    case_suite_execute_records = models.CaseSuiteExecuteRecord.objects.filter().order_by('-id')
    return render(request, 'case_suite_execute_record.html',
                  {'case_suite_execute_records': get_paginator(request, case_suite_execute_records)})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

11.3 定义模板

1）新增“用例集合执行结果”模板：case_suite_execute_record.html

{% extends 'base.html' %}
{% load static %}
{% block title %}测试集合执行结果{% endblock %}

{% block content %}

<div class="table-responsive">
    <table class="table table-striped">
        <thead>
        <tr>
            <th>id</th>
            <th>测试集合名称</th>
            <th>延迟执行时间</th>
            <th>执行状态</th>
            <th>测试结果</th>
            <th>创建者</th>
            <th>创建时间</th>
        </tr>
        </thead>
        <tbody>

        {% for case_suite_execute_record in case_suite_execute_records %}
        <tr>
            <td>{{ case_suite_execute_record.id }}</td>
            <td><a href="">{{ case_suite_execute_record.case_suite.suite_desc }}</a></td>
            <td>{{ case_suite_execute_record.run_time_interval }}</td>
            {% if case_suite_execute_record.status %}
            <td>执行完毕</td>
            {% else %}
            <td>待执行</td>
            {% endif %}
            <td>{{ case_suite_execute_record.test_result|default_if_none:"" }}</td>
            <td>{{ case_suite_execute_record.creator }}</td>
            <td>{{ case_suite_execute_record.create_time|date:"Y-n-d H:i" }}</td>
        </tr>
        {% endfor %}


        </tbody>
    </table>
</div>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if case_suite_execute_records.has_previous %}
                <a class='active' href="?page={{ case_suite_execute_records.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ case_suite_execute_records.number }} 页 / 共 {{ case_suite_execute_records.paginator.num_pages }} 页</span>

                {% if case_suite_execute_records.has_next %}
                <a class='active' href="?page={{ case_suite_execute_records.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

此时，页面中展示了测试集合维度的执行结果，并没有展示其包含的用例的结果，下面处理一下测试集合包含用例的结果展示。 

11.4 集合包含用例结果展示

该页面的实现逻辑与用例执行结果模块类似。

1）定义路由 

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('case_suite/', views.case_suite, name="case_suite"),
    re_path('add_case_in_suite/(?P<suite_id>[0-9]+)', views.add_case_in_suite, name="add_case_in_suite"),
    re_path('show_and_delete_case_in_suite/(?P<suite_id>[0-9]+)', views.show_and_delete_case_in_suite, name="show_and_delete_case_in_suite"),
    path('test_case_execute_record/', views.test_case_execute_record, name="test_case_execute_record"),
    re_path('case_result_diff/(?P<test_record_id>[0-9]+)', views.case_result_diff, name="case_result_diff"),
    re_path('show_exception/(?P<execute_id>[0-9]+)$', views.show_exception, name="show_exception"),
    path('case_suite_execute_record/', views.case_suite_execute_record, name="case_suite_execute_record"),
    re_path('suite_case_execute_record/(?P<suite_record_id>[0-9]+)', views.suite_case_execute_record, name="suite_case_execute_record"),
    re_path('suite_case_result_diff/(?P<suite_case_record_id>[0-9]+)', views.suite_case_result_diff, name="suite_case_result_diff"),
    re_path('suite_case_exception/(?P<suite_case_record_id>[0-9]+)', views.suite_case_exception, name="suite_case_exception"),
]

2）定义视图

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
import json
from . import models
from .task import case_task, suite_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = models.Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = models.Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = models.Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = models.Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = models.InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = models.TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            case_task(test_case_id_list, server_address)
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = models.TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = models.TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = models.Module.objects.get(id=int(module_id))
    test_cases = models.TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合菜单项
@login_required
def case_suite(request):
    if request.method == "POST":
        count_down_time = 0
        if request.POST['delay_time']:
            print("输入的延迟时间是: {}".format(request.POST['delay_time']))
            try:
                count_down_time = int(request.POST['delay_time'])
            except:
                print("输入的延迟时间是非数字！")
        else:
            print("没有输入延迟时间")
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        case_suite_list = request.POST.getlist('case_suite_list')
        if case_suite_list:
            print("所需执行的用例集合列表：", case_suite_list)
            for suite_id in case_suite_list:
                test_suite = models.CaseSuite.objects.get(id=int(suite_id))
                print("所需执行的用例集合: {}".format(test_suite))
                username = request.user.username
                test_suite_record = models.CaseSuiteExecuteRecord.objects.create(case_suite=test_suite,
                                                                               run_time_interval=count_down_time,
                                                                               creator=username)
                suite_task(test_suite_record, test_suite, server_address)
        else:
            print("运行测试集合用例失败")
            return HttpResponse("运行的测试集合为空，请选择测试集合后再运行！")
    case_suites = models.CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = models.TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                models.SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    test_cases = models.SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                models.SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例执行结果-菜单项
@login_required
def test_case_execute_record(request):
    test_case_execute_records = models.TestCaseExecuteResult.objects.filter().order_by('-id')
    return render(request, 'test_case_execute_records.html', {'test_case_execute_records':
                                                                  get_paginator(request, test_case_execute_records)})


# 用例执行结果-对比差异
@login_required
def case_result_diff(request, test_record_id):
    test_record_data = models.TestCaseExecuteResult.objects.get(id=test_record_id)
    print("用例执行结果记录: {}".format(test_record_data))
    present_response = test_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response), sort_keys=True, indent=4,
                                      ensure_ascii=False)  # 中文字符不转ascii编码
        print("当前响应结果: {}".format(present_response))
    last_time_execute_response = test_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True, indent=4,
                                                ensure_ascii=False)
    print("上一次响应结果: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例执行结果-异常信息展示
@login_required
def show_exception(request, execute_id):
    test_record = models.TestCaseExecuteResult.objects.get(id=execute_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果
@login_required
def case_suite_execute_record(request):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.filter().order_by('-id')
    return render(request, 'case_suite_execute_record.html',
                  {'case_suite_execute_records': get_paginator(request, case_suite_execute_record)})


# 用例集合执行结果-包含用例结果展示
@login_required
def suite_case_execute_record(request, suite_record_id):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.get(id=suite_record_id)
    suite_case_execute_records = models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=case_suite_execute_record)
    return render(request, 'suite_case_execute_record.html',
                  {'suite_case_execute_records': get_paginator(request, suite_case_execute_records)})


# 用例集合执行结果-包含用例结果展示-差异比对
@login_required
def suite_case_result_diff(request, suite_case_record_id):
    suite_record_data = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    present_response = suite_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response),sort_keys=True, indent=4, ensure_ascii=False)
        print("当前响应: {}".format(present_response))
    last_time_execute_response = suite_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True,
                                                indent=4, ensure_ascii=False)
    print("上一次响应: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例集合执行结果-包含用例结果展示-异常信息展示
@login_required
def suite_case_exception(request, suite_case_record_id):
    test_record = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

3）定义模板

修改“测试集合执行结果”模板中，测试集合名称链接：

{% extends 'base.html' %}
{% load static %}
{% block title %}测试集合执行结果{% endblock %}

{% block content %}

<div class="table-responsive">
    <table class="table table-striped">
        <thead>
        <tr>
            <th>id</th>
            <th>测试集合名称</th>
            <th>延迟执行时间</th>
            <th>执行状态</th>
            <th>测试结果</th>
            <th>创建者</th>
            <th>创建时间</th>
        </tr>
        </thead>
        <tbody>

        {% for case_suite_execute_record in case_suite_execute_records %}
        <tr>
            <td>{{ case_suite_execute_record.id }}</td>
            <td><a href="{% url 'suite_case_execute_record' case_suite_execute_record.id %}">{{ case_suite_execute_record.case_suite.suite_desc }}</a></td>
            <td>{{ case_suite_execute_record.run_time_interval }}</td>
            {% if case_suite_execute_record.status %}
            <td>执行完毕</td>
            {% else %}
            <td>待执行</td>
            {% endif %}

            {% ifequal case_suite_execute_record.test_result '成功' %}
            <td bgcolor='green'>{{ case_suite_execute_record.test_result}}</td>
            {% else %}
            <td bgcolor='red'>{{ case_suite_execute_record.test_result}}</td>
            {% endifequal %}

            <!--<td>{{ case_suite_execute_record.test_result|default_if_none:"" }}-->
            <td>{{ case_suite_execute_record.creator }}</td>
            <td>{{ case_suite_execute_record.create_time|date:"Y-n-d H:i" }}</td>
        </tr>
        {% endfor %}


        </tbody>
    </table>
</div>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if case_suite_execute_records.has_previous %}
                <a class='active' href="?page={{ case_suite_execute_records.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ case_suite_execute_records.number }} 页 / 共 {{ case_suite_execute_records.paginator.num_pages }} 页</span>

                {% if case_suite_execute_records.has_next %}
                <a class='active' href="?page={{ case_suite_execute_records.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

新增用例集合关联的测试用例执行结果页：templates/suite_case_execute_record.html

{% extends 'base.html' %}
{% load static %}
{% block title %}用例集合用例执行结果{% endblock %}

{% block content %}

    <div class="table-responsive">
            <table class="table table-striped">
              <thead>
                <tr>
                  <th width="5%">执行id</th>
                  <th width="6%">集合名称</th>
                  <th width="5%">用例名称</th>
                  <th width="5%">状态</th>
                  <th width="18%">请求数据</th>
                  <th width="15%">执行返回结果</th>
                  <th width="5%">操作</th>
                  <th width="8%">断言内容</th>
                  <th width="5%">执行结果</th>
                  <th width="5%">异常信息</th>
                  <th width="8%">请求后提取变量</th>
                  <th width="8%">开始时间</th>
                  <th width="8%">执行耗时(ms)</th>
                </tr>
                </thead>
                <tbody>
          
   {% for case_execute_record in suite_case_execute_records %}
           <tr>
      <td>{{ case_execute_record.id }}</td>
      <td>{{ case_execute_record.case_suite_record.case_suite.suite_desc }}</td>
                <td><a href="{% url 'suite_case_execute_record' case_execute_record.test_case.id%}">{{ case_execute_record.test_case.case_name }}</a></td>
                {% if case_execute_record.status %}
                    <td>执行完毕</td>
                {% else %}
                <td>待执行</td>
                {% endif %}
                <td>{{ case_execute_record.request_data }}</td>
                <td>{{ case_execute_record.response_data }}</td>
                <td><a href="{% url 'suite_case_result_diff' case_execute_record.id%}" target="_blank">对比差异</a></td>
                <td>{{ case_execute_record.test_case.assert_key }}</td>

                {% ifequal case_execute_record.execute_result '成功' %}
                <td bgcolor='green'>{{ case_execute_record.execute_result}}</td>
                {% else %}
                <td bgcolor='red'>{{ case_execute_record.execute_result}}</td>
                {% endifequal %}

                <！--<td>{{ case_execute_record.execute_result|default_if_none:"" }}</td>--!>
                {% if case_execute_record.exception_info %}
                      <td><a href="{% url 'suite_case_exception' case_execute_record.id%}" target="_blank">显示异常</a></td>
                {% else %}
                <td>无</td>
                {% endif %}
                <td>{{ case_execute_record.extract_var }}</td>
                <td>{{ case_execute_record.execute_start_time }}</td>
                <td>{{ case_execute_record.execute_total_time }}</td>

                </tr>
   {% endfor %}
                  
             
             </tbody>
            </table>
    </div>

    {# 实现分页标签的代码 #}
    {# 这里使用 bootstrap 渲染页面 #}
    <div id="pages" class="text-center" >
        <nav>
            <ul class="pagination">
                <li class="step-links">
                {% if suite_case_execute_records.has_previous %}
                    <a class='active' href="?page={{ suite_case_execute_records.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ suite_case_execute_records.number }} 页 / 共 {{ suite_case_execute_records.paginator.num_pages }} 页</span>

                {% if suite_case_execute_records.has_next %}
                    <a class='active' href="?page={{ suite_case_execute_records.next_page_number }}">下一页</a>
                {% endif %}
                </li></ul></nav></div>
{% endblock %}

 

12. 用例集合历史执行结果统计

1）定义路由

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('case_suite/', views.case_suite, name="case_suite"),
    re_path('add_case_in_suite/(?P<suite_id>[0-9]+)', views.add_case_in_suite, name="add_case_in_suite"),
    re_path('show_and_delete_case_in_suite/(?P<suite_id>[0-9]+)', views.show_and_delete_case_in_suite, name="show_and_delete_case_in_suite"),
    path('test_case_execute_record/', views.test_case_execute_record, name="test_case_execute_record"),
    re_path('case_result_diff/(?P<test_record_id>[0-9]+)', views.case_result_diff, name="case_result_diff"),
    re_path('show_exception/(?P<execute_id>[0-9]+)$', views.show_exception, name="show_exception"),
    path('case_suite_execute_record/', views.case_suite_execute_record, name="case_suite_execute_record"),
    re_path('suite_case_execute_record/(?P<suite_record_id>[0-9]+)', views.suite_case_execute_record, name="suite_case_execute_record"),
    re_path('suite_case_result_diff/(?P<suite_case_record_id>[0-9]+)', views.suite_case_result_diff, name="suite_case_result_diff"),
    re_path('suite_case_exception/(?P<suite_case_record_id>[0-9]+)', views.suite_case_exception, name="suite_case_exception"),
    re_path('case_suite_statistics/(?P<suite_id>[0-9]+)', views.case_suite_statistics, name="case_suite_statistics"),
]

2）定义视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
import json
from . import models
from .task import case_task, suite_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = models.Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = models.Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = models.Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = models.Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = models.InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = models.TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            case_task(test_case_id_list, server_address)
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = models.TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = models.TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = models.Module.objects.get(id=int(module_id))
    test_cases = models.TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合菜单项
@login_required
def case_suite(request):
    if request.method == "POST":
        count_down_time = 0
        if request.POST['delay_time']:
            print("输入的延迟时间是: {}".format(request.POST['delay_time']))
            try:
                count_down_time = int(request.POST['delay_time'])
            except:
                print("输入的延迟时间是非数字！")
        else:
            print("没有输入延迟时间")
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        case_suite_list = request.POST.getlist('case_suite_list')
        if case_suite_list:
            print("所需执行的用例集合列表：", case_suite_list)
            for suite_id in case_suite_list:
                test_suite = models.CaseSuite.objects.get(id=int(suite_id))
                print("所需执行的用例集合: {}".format(test_suite))
                username = request.user.username
                test_suite_record = models.CaseSuiteExecuteRecord.objects.create(case_suite=test_suite,
                                                                               run_time_interval=count_down_time,
                                                                               creator=username)
                suite_task(test_suite_record, test_suite, server_address)
        else:
            print("运行测试集合用例失败")
            return HttpResponse("运行的测试集合为空，请选择测试集合后再运行！")
    case_suites = models.CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = models.TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                models.SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    test_cases = models.SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                models.SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例执行结果-菜单项
@login_required
def test_case_execute_record(request):
    test_case_execute_records = models.TestCaseExecuteResult.objects.filter().order_by('-id')
    return render(request, 'test_case_execute_records.html', {'test_case_execute_records':
                                                                  get_paginator(request, test_case_execute_records)})


# 用例执行结果-对比差异
@login_required
def case_result_diff(request, test_record_id):
    test_record_data = models.TestCaseExecuteResult.objects.get(id=test_record_id)
    print("用例执行结果记录: {}".format(test_record_data))
    present_response = test_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response), sort_keys=True, indent=4,
                                      ensure_ascii=False)  # 中文字符不转ascii编码
        print("当前响应结果: {}".format(present_response))
    last_time_execute_response = test_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True, indent=4,
                                                ensure_ascii=False)
    print("上一次响应结果: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例执行结果-异常信息展示
@login_required
def show_exception(request, execute_id):
    test_record = models.TestCaseExecuteResult.objects.get(id=execute_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果
@login_required
def case_suite_execute_record(request):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.filter().order_by('-id')
    return render(request, 'case_suite_execute_record.html',
                  {'case_suite_execute_records': get_paginator(request, case_suite_execute_record)})


# 用例集合执行结果-包含用例结果展示
@login_required
def suite_case_execute_record(request, suite_record_id):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.get(id=suite_record_id)
    suite_case_execute_records = models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=case_suite_execute_record)
    return render(request, 'suite_case_execute_record.html',
                  {'suite_case_execute_records': get_paginator(request, suite_case_execute_records)})


# 用例集合执行结果-包含用例结果展示-差异比对
@login_required
def suite_case_result_diff(request, suite_case_record_id):
    suite_record_data = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    present_response = suite_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response),sort_keys=True, indent=4, ensure_ascii=False)
        print("当前响应: {}".format(present_response))
    last_time_execute_response = suite_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True,
                                                indent=4, ensure_ascii=False)
    print("上一次响应: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例集合执行结果-包含用例结果展示-异常信息展示
@login_required
def suite_case_exception(request, suite_case_record_id):
    test_record = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果统计
def case_suite_statistics(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    success_num = len(models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite, test_result="成功"))
    fail_num = len(models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite, test_result="失败"))
    case_suite_records = models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite).order_by('-id')
    return render(request, 'case_suite_statistics.html',
                  {'case_suite_records': get_paginator(request, case_suite_records), 'success_num': success_num,
                   'fail_num': fail_num})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

3）定义模板

修改 case_suite.html 模板，增加查看统计结果链接：

{% extends 'base.html' %}
{% load static %}
{% block title %}用例集合{% endblock %}
{% block content %}
<script>
    //页面加载的时候,所有的复选框都是未选中的状态
    function checkOrCancelAll() {
        var all_check = document.getElementById("all_check");  // 1.获取all的元素对象
        var all_check = all_check.checked;  // 2.获取选中状态
        // 3.若checked=true,将所有的复选框选中,checked=false,将所有的复选框取消
        var allCheck = document.getElementsByName("case_suite_list");
        // 4.循环遍历取出每一个复选框中的元素
        if (all_check)//全选
        {
            for (var i = 0; i < allCheck.length; i++) {
                //设置复选框的选中状态
                allCheck[i].checked = true;
            }
        } else//取消全选
        {
            for (var i = 0; i < allCheck.length; i++) {
                allCheck[i].checked = false;
            }
        }
    }
    function ischecked() {
        // 3.若checked=true,将所有的复选框选中,checked=false,将所有的复选框取消
        var allCheck = document.getElementsByName("case_suite_list");
        for (var i = 0; i < allCheck.length; i++) {

            if (allCheck[i].checked == true) {
                alert("所需执行的测试集合提交成功！");
                return true
            }
        }
        alert("请选择要执行的测试集合！")
        return false
    }
</script>

<form action="" method="POST">
    {% csrf_token %}
    <span style="margin-left: 5px;">延迟执行的时间（单位：秒）:</span>
    <input type="text" style="width: 70px; margin-left: 5px; margin-right: 10px;" placeholder="请输入" name="delay_time"/>
    <span style="margin-left: 5px;">运行环境：</span>
    <select name="env">
        <option selected value="dev">dev</option>
        <option value="prod">prod</option>
    </select>
    <input style="margin-left: 10px;" type="submit" id="all_check1" value='运行测试集合' onclick="return ischecked()"/>

    <div class="table-responsive">
        <table class="table table-striped">
            <thead>
            <tr>
                <th><input type="checkbox" id="all_check" onclick="checkOrCancelAll();"/>全选</th>
                <th>id</th>
                <th>测试集合名称</th>
                <th>创建者</th>
                <th>创建时间</th>
                <th>查看/删除测试用例</th>
                <th>添加测试用例</th>
                <th>用例集合执行结果</th>
            </tr>
            </thead>
            <tbody>

            {% for case_suite in case_suites %}
            <tr>
                <td><input type="checkbox" value="{{ case_suite.id }}" name="case_suite_list"></td>
                <td>{{ case_suite.id }}</td>
                <td>{{ case_suite.suite_desc }}</td>
                <td>{{ case_suite.creator }}</td>
                <td>{{ case_suite.create_time|date:"Y-n-d H:i" }}</td>
                <td><a href="{% url 'show_and_delete_case_in_suite' case_suite.id %}">查看/删除测试用例</a></td>
                <td><a href="{% url 'add_case_in_suite' case_suite.id %}">添加测试用例</a></td>
                <td><a href="{% url 'case_suite_statistics' case_suite.id %}">查看用例集合执行结果</a></td>
            </tr>
            {% endfor %}
            </tbody>
        </table>
    </div>
</form>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if case_suites.has_previous %}
                <a class='active' href="?page={{ case_suites.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ case_suites.number }} 页 / 共 {{ case_suites.paginator.num_pages }} 页</span>

                {% if case_suites.has_next %}
                <a class='active' href="?page={{ case_suites.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

新增统计结果页面模板：templates/case_suite_statistics.html

{% extends 'base.html' %}
{% load static %}
{% block title %}测试集合结果统计{% endblock %}
{% block content %}


<body>
<p style="margin-left: 10px;">
    <span style="margin-left: 5px;">用例集合执行结果统计：成功 {{ success_num }} 次，失败 {{ fail_num }} 次</span>
<p>
<div id="main" style="width: 600px;height:400px; margin-left: 10px;"></div>
<!--<script src="{% static 'js/echarts.simple.min.js' %}"></script>-->
<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/echarts@5/dist/echarts.min.js"></script>
<script>
        // 绘制图表。
        echarts.init(document.getElementById('main')).setOption({
            series: {
                type: 'pie',
                color: ['green', 'red'],
                data: [
                    {name: '成功的次数', value: {{ success_num }}},
                    {name: '失败的次数', value: {{ fail_num }}},
                ]
            }
        });
        echarts.init(document.getElementById('main')).setOption({
            title: {
                text: '结果统计',
                subtext: '即时数据',
                left: 'center'
            },
            tooltip: {
                trigger: 'item'
            },
            legend: {
               orient: 'vertical',
               left: 'left'
            },
            series: {
                name: '结果统计',
                radius: '55%',
                type: 'pie',
                color: ['green', 'red'],
                data: [
                    {name: '执行成功次数', value: {{ success_num }}},
                    {name: '执行失败次数', value: {{ fail_num }}},

                ],
                 label:{  // 饼图图形上的文本标签
                        normal:{
                            show:true,
                            formatter: "{b} : {c} ({d}%)"
                        }
                 }
            }
        });
</script>

<div class="table-responsive">
    <table class="table table-striped">
        <thead>
        <tr>
            <th>id</th>
            <th>测试集合名称</th>
            <th>延迟执行时间</th>
            <th>执行状态</th>
            <th>测试结果</th>
            <th>创建者</th>
            <th>创建时间</th>
        </tr>
        </thead>
        <tbody>

        {% for case_suite_record in case_suite_records %}
        <tr>
            <td>{{ case_suite_record.id }}</td>
            <td><a href="{% url 'suite_case_execute_record' case_suite_record.id %}">{{ case_suite_record.case_suite.suite_desc }}</a></td>
            <td>{{ case_suite_record.run_time_interval }}</a></td>
            {% if case_suite_record.status %}
                <td>执行完毕</td>
            {% else %}
                <td>待执行</td>
            {% endif %}
            <td>{{ case_suite_record.test_result|default_if_none:"" }}</a></td>
            <td>{{ case_suite_record.creator }}</td>
            <td>{{ case_suite_record.create_time|date:"Y-n-d H:i" }}</td>
        </tr>
        {% endfor %}

        </tbody>
    </table>
</div>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if case_suite_records.has_previous %}
                <a class='active' href="?page={{ case_suite_records.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ case_suite_records.number }} 页 / 共 {{ case_suite_records.paginator.num_pages }} 页</span>

                {% if case_suite_records.has_next %}
                <a class='active' href="?page={{ case_suite_records.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
</body>

{% endblock %}

 

13. 用例集合单次执行结果统计

1）定义路由

 

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('case_suite/', views.case_suite, name="case_suite"),
    re_path('add_case_in_suite/(?P<suite_id>[0-9]+)', views.add_case_in_suite, name="add_case_in_suite"),
    re_path('show_and_delete_case_in_suite/(?P<suite_id>[0-9]+)', views.show_and_delete_case_in_suite, name="show_and_delete_case_in_suite"),
    path('test_case_execute_record/', views.test_case_execute_record, name="test_case_execute_record"),
    re_path('case_result_diff/(?P<test_record_id>[0-9]+)', views.case_result_diff, name="case_result_diff"),
    re_path('show_exception/(?P<execute_id>[0-9]+)$', views.show_exception, name="show_exception"),
    path('case_suite_execute_record/', views.case_suite_execute_record, name="case_suite_execute_record"),
    re_path('suite_case_execute_record/(?P<suite_record_id>[0-9]+)', views.suite_case_execute_record, name="suite_case_execute_record"),
    re_path('suite_case_result_diff/(?P<suite_case_record_id>[0-9]+)', views.suite_case_result_diff, name="suite_case_result_diff"),
    re_path('suite_case_exception/(?P<suite_case_record_id>[0-9]+)', views.suite_case_exception, name="suite_case_exception"),
    re_path('suite_case_statistics/(?P<suite_id>[0-9]+)', views.suite_case_statistics, name="suite_case_statistics"),
    re_path('case_suite_statistics/(?P<suite_id>[0-9]+)', views.case_suite_statistics, name="case_suite_statistics"),
]

2）定义视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
import json
from . import models
from .task import case_task, suite_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = models.Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = models.Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = models.Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = models.Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = models.InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = models.TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            case_task(test_case_id_list, server_address)
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = models.TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = models.TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = models.Module.objects.get(id=int(module_id))
    test_cases = models.TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合菜单项
@login_required
def case_suite(request):
    if request.method == "POST":
        count_down_time = 0
        if request.POST['delay_time']:
            print("输入的延迟时间是: {}".format(request.POST['delay_time']))
            try:
                count_down_time = int(request.POST['delay_time'])
            except:
                print("输入的延迟时间是非数字！")
        else:
            print("没有输入延迟时间")
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        case_suite_list = request.POST.getlist('case_suite_list')
        if case_suite_list:
            print("所需执行的用例集合列表：", case_suite_list)
            for suite_id in case_suite_list:
                test_suite = models.CaseSuite.objects.get(id=int(suite_id))
                print("所需执行的用例集合: {}".format(test_suite))
                username = request.user.username
                test_suite_record = models.CaseSuiteExecuteRecord.objects.create(case_suite=test_suite,
                                                                               run_time_interval=count_down_time,
                                                                               creator=username)
                suite_task(test_suite_record, test_suite, server_address)
        else:
            print("运行测试集合用例失败")
            return HttpResponse("运行的测试集合为空，请选择测试集合后再运行！")
    case_suites = models.CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = models.TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                models.SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    test_cases = models.SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                models.SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例执行结果-菜单项
@login_required
def test_case_execute_record(request):
    test_case_execute_records = models.TestCaseExecuteResult.objects.filter().order_by('-id')
    return render(request, 'test_case_execute_records.html', {'test_case_execute_records':
                                                                  get_paginator(request, test_case_execute_records)})


# 用例执行结果-对比差异
@login_required
def case_result_diff(request, test_record_id):
    test_record_data = models.TestCaseExecuteResult.objects.get(id=test_record_id)
    print("用例执行结果记录: {}".format(test_record_data))
    present_response = test_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response), sort_keys=True, indent=4,
                                      ensure_ascii=False)  # 中文字符不转ascii编码
        print("当前响应结果: {}".format(present_response))
    last_time_execute_response = test_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True, indent=4,
                                                ensure_ascii=False)
    print("上一次响应结果: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例执行结果-异常信息展示
@login_required
def show_exception(request, execute_id):
    test_record = models.TestCaseExecuteResult.objects.get(id=execute_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果
@login_required
def case_suite_execute_record(request):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.filter().order_by('-id')
    return render(request, 'case_suite_execute_record.html',
                  {'case_suite_execute_records': get_paginator(request, case_suite_execute_record)})


# 用例集合执行结果-包含用例结果展示
@login_required
def suite_case_execute_record(request, suite_record_id):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.get(id=suite_record_id)
    suite_case_execute_records = models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=case_suite_execute_record)
    return render(request, 'suite_case_execute_record.html',
                  {'suite_case_execute_records': get_paginator(request, suite_case_execute_records)})


# 用例集合执行结果-包含用例结果展示-差异比对
@login_required
def suite_case_result_diff(request, suite_case_record_id):
    suite_record_data = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    present_response = suite_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response),sort_keys=True, indent=4, ensure_ascii=False)
        print("当前响应: {}".format(present_response))
    last_time_execute_response = suite_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True,
                                                indent=4, ensure_ascii=False)
    print("上一次响应: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例集合执行结果-包含用例结果展示-异常信息展示
@login_required
def suite_case_exception(request, suite_case_record_id):
    test_record = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果单次统计
def suite_case_statistics(request, suite_id):
    success_num = len(models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id, execute_result="成功"))
    fail_num = len(models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id, execute_result="失败"))
    suite_case_records = models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id).order_by('-id')
    return render(request, 'suite_case_statistics.html',
                  {'suite_case_records': get_paginator(request, suite_case_records), 'success_num': success_num,
                   'fail_num': fail_num})


# 用例集合执行结果历史统计
def case_suite_statistics(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    success_num = len(models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite, test_result="成功"))
    fail_num = len(models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite, test_result="失败"))
    case_suite_records = models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite).order_by('-id')
    return render(request, 'case_suite_statistics.html',
                  {'case_suite_records': get_paginator(request, case_suite_records), 'success_num': success_num,
                   'fail_num': fail_num})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

3）定义模板

修改 case_suite_execute_record.html：新增测试结果统计链接

{% extends 'base.html' %}
{% load static %}
{% block title %}测试集合执行结果{% endblock %}

{% block content %}

<div class="table-responsive">
    <table class="table table-striped">
        <thead>
        <tr>
            <th>id</th>
            <th>测试集合名称</th>
            <th>延迟执行时间</th>
            <th>执行状态</th>
            <th>测试结果</th>
            <th>测试结果统计</th>
            <th>创建者</th>
            <th>创建时间</th>
        </tr>
        </thead>
        <tbody>

        {% for case_suite_execute_record in case_suite_execute_records %}
        <tr>
            <td>{{ case_suite_execute_record.id }}</td>
            <td><a href="{% url 'suite_case_execute_record' case_suite_execute_record.id %}">{{ case_suite_execute_record.case_suite.suite_desc }}</a></td>
            <td>{{ case_suite_execute_record.run_time_interval }}</td>
            {% if case_suite_execute_record.status %}
            <td>执行完毕</td>
            {% else %}
            <td>待执行</td>
            {% endif %}

            {% ifequal case_suite_execute_record.test_result '成功' %}
            <td bgcolor='green'>{{ case_suite_execute_record.test_result}}</td>
            {% else %}
            <td bgcolor='red'>{{ case_suite_execute_record.test_result}}</td>
            {% endifequal %}
            <td><a href="{% url 'suite_case_statistics' case_suite_execute_record.id %}">测试结果统计</a></td>
            <td>{{ case_suite_execute_record.creator }}</td>
            <td>{{ case_suite_execute_record.create_time|date:"Y-n-d H:i" }}</td>
        </tr>
        {% endfor %}


        </tbody>
    </table>
</div>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if case_suite_execute_records.has_previous %}
                <a class='active' href="?page={{ case_suite_execute_records.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ case_suite_execute_records.number }} 页 / 共 {{ case_suite_execute_records.paginator.num_pages }} 页</span>

                {% if case_suite_execute_records.has_next %}
                <a class='active' href="?page={{ case_suite_execute_records.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

新增 templates/suite_case_statistics.html：

{% extends 'base.html' %}
{% load static %}
{% block title %}用例集合单次执行结果统计{% endblock %}
{% block content %}


<body>
<p style="margin-left: 10px;">
    <span style="margin-left: 5px;">用例集合执行结果统计：成功 {{ success_num }} 次，失败 {{ fail_num }} 次</span>
<p>
<div id="main" style="width: 600px;height:400px; margin-left: 10px;"></div>
<!--<script src="{% static 'js/echarts.simple.min.js' %}"></script>-->
<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/echarts@5/dist/echarts.min.js"></script>
<script>
        // 绘制图表。
        echarts.init(document.getElementById('main')).setOption({
            series: {
                type: 'pie',
                color: ['green', 'red'],
                data: [
                    {name: '通过用例数', value: {{ success_num }}},
                    {name: '失败用例数', value: {{ fail_num }}},
                ]
            }
        });
        echarts.init(document.getElementById('main')).setOption({
            title: {
                text: '结果统计',
                subtext: '即时数据',
                left: 'center'
            },
            tooltip: {
                trigger: 'item'
            },
            legend: {
               orient: 'vertical',
               left: 'left'
            },
            series: {
                name: '结果统计',
                radius: '55%',
                type: 'pie',
                color: ['green', 'red'],
                data: [
                    {name: '通过用例数', value: {{ success_num }}},
                    {name: '失败用例数', value: {{ fail_num }}},

                ],
                 label:{  // 饼图图形上的文本标签
                        normal:{
                            show:true,
                            formatter: "{b} : {c} ({d}%)"
                        }
                 }
            }
        });
</script>

                <table class="table table-striped">
                    <thead>
                    <tr>
                        <th>测试集合名称</th>
                        <th width="6%">用例id</th>
                        <th>用例名称</th>
                        <th>所属项目</th>
                        <th>所属模块</th>
                        <th>编写人员</th>
                        <th>创建时间</th>
                        <th>更新时间</th>
                        <th>创建用例用户名</th>
                    </tr>
                    </thead>
                    <tbody>

                    {% for suite_case in suite_case_records %}
                    <tr>
                        <td>{{suite_case.case_suite_record.case_suite.suite_desc}}</td>
                        <td>{{ suite_case.id }}</td>
                        <td><a href="{% url 'test_case_detail' suite_case.id%}">{{ suite_case.test_case.case_name }}</a></td>
                        <td>{{ suite_case.test_case.belong_project.name }}</td>
                        <td>{{ suite_case.test_case.belong_module.name }}</td>
                        <td>{{ suite_case.test_case.maintainer }}</td>
                        <td>{{ suite_case.test_case.created_time|date:"Y-n-d H:i" }}</td>
                        <td>{{ suite_case.test_case.updated_time|date:"Y-n-d H:i" }}</td>
                        <td>{{ suite_case.test_case.user }}</td>
                    </tr>
                    {% endfor %}
                    </tbody>
                </table>
            </div>
        </form>

        {# 实现分页标签的代码 #}
        {# 这里使用 bootstrap 渲染页面 #}
        <div id="pages" class="text-center">
            <nav>
                <ul class="pagination">
                    <li class="step-links">
                        {% if suite_case_records.has_previous %}
                        <a class='active' href="?page={{ suite_case_records.previous_page_number }}">上一页</a>
                        {% endif %}

                        <span class="current">
                    第 {{ suite_case_records.number }} 页 / 共 {{ suite_case_records.paginator.num_pages }} 页</span>

                        {% if suite_case_records.has_next %}
                        <a class='active' href="?page={{ suite_case_records.next_page_number }}">下一页</a>
                        {% endif %}
                    </li>
                </ul>
            </nav>
        </div>
    </div>
</div>
</body>
{% endblock %}

 

14. 模块测试结果统计

1）定义路由

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('case_suite/', views.case_suite, name="case_suite"),
    re_path('add_case_in_suite/(?P<suite_id>[0-9]+)', views.add_case_in_suite, name="add_case_in_suite"),
    re_path('show_and_delete_case_in_suite/(?P<suite_id>[0-9]+)', views.show_and_delete_case_in_suite, name="show_and_delete_case_in_suite"),
    path('test_case_execute_record/', views.test_case_execute_record, name="test_case_execute_record"),
    re_path('case_result_diff/(?P<test_record_id>[0-9]+)', views.case_result_diff, name="case_result_diff"),
    re_path('show_exception/(?P<execute_id>[0-9]+)$', views.show_exception, name="show_exception"),
    path('case_suite_execute_record/', views.case_suite_execute_record, name="case_suite_execute_record"),
    re_path('suite_case_execute_record/(?P<suite_record_id>[0-9]+)', views.suite_case_execute_record, name="suite_case_execute_record"),
    re_path('suite_case_result_diff/(?P<suite_case_record_id>[0-9]+)', views.suite_case_result_diff, name="suite_case_result_diff"),
    re_path('suite_case_exception/(?P<suite_case_record_id>[0-9]+)', views.suite_case_exception, name="suite_case_exception"),
    re_path('suite_case_statistics/(?P<suite_id>[0-9]+)', views.suite_case_statistics, name="suite_case_statistics"),
    re_path('case_suite_statistics/(?P<suite_id>[0-9]+)', views.case_suite_statistics, name="case_suite_statistics"),
    re_path('module_statistics/(?P<module_id>[0-9]+)', views.module_statistics, name="module_statistics"),
]

2）定义视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
import json
from . import models
from .task import case_task, suite_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = models.Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = models.Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = models.Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = models.Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = models.InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = models.TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            case_task(test_case_id_list, server_address)
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = models.TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = models.TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = models.Module.objects.get(id=int(module_id))
    test_cases = models.TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合菜单项
@login_required
def case_suite(request):
    if request.method == "POST":
        count_down_time = 0
        if request.POST['delay_time']:
            print("输入的延迟时间是: {}".format(request.POST['delay_time']))
            try:
                count_down_time = int(request.POST['delay_time'])
            except:
                print("输入的延迟时间是非数字！")
        else:
            print("没有输入延迟时间")
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        case_suite_list = request.POST.getlist('case_suite_list')
        if case_suite_list:
            print("所需执行的用例集合列表：", case_suite_list)
            for suite_id in case_suite_list:
                test_suite = models.CaseSuite.objects.get(id=int(suite_id))
                print("所需执行的用例集合: {}".format(test_suite))
                username = request.user.username
                test_suite_record = models.CaseSuiteExecuteRecord.objects.create(case_suite=test_suite,
                                                                               run_time_interval=count_down_time,
                                                                               creator=username)
                suite_task(test_suite_record, test_suite, server_address)
        else:
            print("运行测试集合用例失败")
            return HttpResponse("运行的测试集合为空，请选择测试集合后再运行！")
    case_suites = models.CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = models.TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                models.SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    test_cases = models.SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                models.SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例执行结果-菜单项
@login_required
def test_case_execute_record(request):
    test_case_execute_records = models.TestCaseExecuteResult.objects.filter().order_by('-id')
    return render(request, 'test_case_execute_records.html', {'test_case_execute_records':
                                                                  get_paginator(request, test_case_execute_records)})


# 用例执行结果-对比差异
@login_required
def case_result_diff(request, test_record_id):
    test_record_data = models.TestCaseExecuteResult.objects.get(id=test_record_id)
    print("用例执行结果记录: {}".format(test_record_data))
    present_response = test_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response), sort_keys=True, indent=4,
                                      ensure_ascii=False)  # 中文字符不转ascii编码
        print("当前响应结果: {}".format(present_response))
    last_time_execute_response = test_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True, indent=4,
                                                ensure_ascii=False)
    print("上一次响应结果: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例执行结果-异常信息展示
@login_required
def show_exception(request, execute_id):
    test_record = models.TestCaseExecuteResult.objects.get(id=execute_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果
@login_required
def case_suite_execute_record(request):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.filter().order_by('-id')
    return render(request, 'case_suite_execute_record.html',
                  {'case_suite_execute_records': get_paginator(request, case_suite_execute_record)})


# 用例集合执行结果-包含用例结果展示
@login_required
def suite_case_execute_record(request, suite_record_id):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.get(id=suite_record_id)
    suite_case_execute_records = models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=case_suite_execute_record)
    return render(request, 'suite_case_execute_record.html',
                  {'suite_case_execute_records': get_paginator(request, suite_case_execute_records)})


# 用例集合执行结果-包含用例结果展示-差异比对
@login_required
def suite_case_result_diff(request, suite_case_record_id):
    suite_record_data = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    present_response = suite_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response),sort_keys=True, indent=4, ensure_ascii=False)
        print("当前响应: {}".format(present_response))
    last_time_execute_response = suite_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True,
                                                indent=4, ensure_ascii=False)
    print("上一次响应: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例集合执行结果-包含用例结果展示-异常信息展示
@login_required
def suite_case_exception(request, suite_case_record_id):
    test_record = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果单次统计
def suite_case_statistics(request, suite_id):
    success_num = len(models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id, execute_result="成功"))
    fail_num = len(models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id, execute_result="失败"))
    suite_case_records = models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id).order_by('-id')
    return render(request, 'suite_case_statistics.html',
                  {'suite_case_records': get_paginator(request, suite_case_records), 'success_num': success_num,
                   'fail_num': fail_num})


# 用例集合执行结果历史统计
def case_suite_statistics(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    success_num = len(models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite, test_result="成功"))
    fail_num = len(models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite, test_result="失败"))
    case_suite_records = models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite).order_by('-id')
    return render(request, 'case_suite_statistics.html',
                  {'case_suite_records': get_paginator(request, case_suite_records), 'success_num': success_num,
                   'fail_num': fail_num})

# 模块测试结果统计
@login_required
def module_statistics(request, module_id):
    test_module = models.Module.objects.get(id=int(module_id))
    test_cases = models.TestCase.objects.filter(belong_module=test_module)
    test_suit_success_num = len(
        models.CaseSuiteTestCaseExecuteRecord.objects.filter(test_case__in=test_cases, execute_result="成功"))
    test_suit_fail_num = len(
        models.CaseSuiteTestCaseExecuteRecord.objects.filter(test_case__in=test_cases, execute_result="失败"))
    test_case_success_num = len(
        models.TestCaseExecuteResult.objects.filter(belong_test_case__in=test_cases, execute_result="成功"))
    test_case_fail_num = len(
        models.TestCaseExecuteResult.objects.filter(belong_test_case__in=test_cases, execute_result="失败"))
    success_num = test_suit_success_num + test_case_success_num
    fail_num = test_suit_fail_num + test_case_fail_num
    return render(request, 'module_statistics.html',
                  {'test_module': test_module, 'success_num': success_num, 'fail_num': fail_num})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

3）定义模板

模块页面 module.html 新增测试结果统计的链接：

{% extends 'base.html' %}
{% load static %}
{% block title %}模块{% endblock %}

{% block content %}
<form action="{% url 'module'%}" method="POST">
    {% csrf_token %}
    <input style="margin-left: 5px;" type="text" name="proj_name" value="{{ proj_name }}" placeholder="输入项目名称搜索模块">
    <input type="submit" value="搜索">
</form>

<div class="table-responsive">

    <table class="table table-striped">
        <thead>
        <tr>
            <th>id</th>
            <th>模块名称</th>
            <th>所属项目</th>
            <th>测试负责人</th>
            <th>模块描述</th>
            <th>创建时间</th>
            <th>更新时间</th>
            <th>测试结果统计</th>
        </tr>
        </thead>
        <tbody>

        {% for module in modules %}
        <tr>
            <td>{{ module.id }}</td>
            <td><a href="{% url 'module_test_cases' module.id %}">{{ module.name }}</a></td>
            <td>{{ module.belong_project.name }}</td>
            <td>{{ module.test_owner }}</td>
            <td>{{ module.desc }}</td>
            <td>{{ module.create_time|date:"Y-n-d H:i" }}</td>
            <td>{{ module.update_time|date:"Y-n-d H:i" }}</td>
            <td><a href="{% url 'module_statistics' module.id %}">查看</a></td>
        </tr>
        {% endfor %}

        </tbody>
    </table>
</div>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if modules.has_previous %}
                <a class='active' href="?page={{ modules.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                    第 {{ modules.number }} 页 / 共 {{ modules.paginator.num_pages }} 页</span>

                {% if modules.has_next %}
                <a class='active' href="?page={{ modules.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

新增模块测试结果统计模板 module_statistics.html：

{% extends 'base.html' %}
{% load static %}
{% block title %}模块测试结果统计{% endblock %}
{% block content %}

<style>
    .center{
         width:500px,
         margin-left: 10px;
         background-color: bisque;
         }


</style>
<body>
<p style="margin-left: 10px;">
    <span style="margin-left: 5px;"> 【{{ test_module.name }}】执行统计结果：成功 {{ success_num }} 次，失败 {{ fail_num }} 次</span>
</p>
<p style="margin-left: 10px;">
    <span></span>
</p>
<div class="center" id="main" style="width: 600px; height:400px; margin-left: 10px;" align="center"></div>
<!--<script src="{% static 'js/echarts.simple.min.js' %}"></script>-->
<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/echarts@5/dist/echarts.min.js"></script>
<script>
        // 绘制图表。
        echarts.init(document.getElementById('main')).setOption({
            title: {
                text: '统计结果',
                subtext: '即时数据',
                left: 'center'
            },
            tooltip: {
                trigger: 'item'
            },
            legend: {
               orient: 'vertical',
               left: 'left'
            },
            series: {
                name: '结果统计',
                radius: '55%',
                type: 'pie',
                color: ['green', 'red'],
                data: [
                    {name: '成功用例数', value: {{ success_num }}},
                    {name: '失败用例数', value: {{ fail_num }}},

                ],
                label:{
                        normal:{
                            show:true,
                            formatter: "{b} : {c} ({d}%)"
                        }
                    }
            }
        });

</script>
</body>

{% endblock %}

 

15. 项目测试结果统计

1）定义路由

from django.urls import path, re_path
from . import views


urlpatterns = [
    path('', views.index),
    path('login/', views.login),
    path('logout/', views.logout),
    path('project/', views.project, name='project'),
    path('module/', views.module, name='module'),
    path('test_case/', views.test_case, name="test_case"),
    re_path('test_case_detail/(?P<test_case_id>[0-9]+)', views.test_case_detail, name="test_case_detail"),
    re_path('module_test_cases/(?P<module_id>[0-9]+)/$', views.module_test_cases, name="module_test_cases"),
    path('case_suite/', views.case_suite, name="case_suite"),
    re_path('add_case_in_suite/(?P<suite_id>[0-9]+)', views.add_case_in_suite, name="add_case_in_suite"),
    re_path('show_and_delete_case_in_suite/(?P<suite_id>[0-9]+)', views.show_and_delete_case_in_suite, name="show_and_delete_case_in_suite"),
    path('test_case_execute_record/', views.test_case_execute_record, name="test_case_execute_record"),
    re_path('case_result_diff/(?P<test_record_id>[0-9]+)', views.case_result_diff, name="case_result_diff"),
    re_path('show_exception/(?P<execute_id>[0-9]+)$', views.show_exception, name="show_exception"),
    path('case_suite_execute_record/', views.case_suite_execute_record, name="case_suite_execute_record"),
    re_path('suite_case_execute_record/(?P<suite_record_id>[0-9]+)', views.suite_case_execute_record, name="suite_case_execute_record"),
    re_path('suite_case_result_diff/(?P<suite_case_record_id>[0-9]+)', views.suite_case_result_diff, name="suite_case_result_diff"),
    re_path('suite_case_exception/(?P<suite_case_record_id>[0-9]+)', views.suite_case_exception, name="suite_case_exception"),
    re_path('suite_case_statistics/(?P<suite_id>[0-9]+)', views.suite_case_statistics, name="suite_case_statistics"),
    re_path('case_suite_statistics/(?P<suite_id>[0-9]+)', views.case_suite_statistics, name="case_suite_statistics"),
    re_path('module_statistics/(?P<module_id>[0-9]+)', views.module_statistics, name="module_statistics"),
    re_path('project_statistics/(?P<project_id>[0-9]+)', views.project_statistics, name="project_statistics"),
]

2）定义视图函数

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
import json
from . import models
from .task import case_task, suite_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = models.Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = models.Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = models.Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = models.Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = models.InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = models.TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            case_task(test_case_id_list, server_address)
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = models.TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = models.TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = models.Module.objects.get(id=int(module_id))
    test_cases = models.TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合菜单项
@login_required
def case_suite(request):
    if request.method == "POST":
        count_down_time = 0
        if request.POST['delay_time']:
            print("输入的延迟时间是: {}".format(request.POST['delay_time']))
            try:
                count_down_time = int(request.POST['delay_time'])
            except:
                print("输入的延迟时间是非数字！")
        else:
            print("没有输入延迟时间")
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        case_suite_list = request.POST.getlist('case_suite_list')
        if case_suite_list:
            print("所需执行的用例集合列表：", case_suite_list)
            for suite_id in case_suite_list:
                test_suite = models.CaseSuite.objects.get(id=int(suite_id))
                print("所需执行的用例集合: {}".format(test_suite))
                username = request.user.username
                test_suite_record = models.CaseSuiteExecuteRecord.objects.create(case_suite=test_suite,
                                                                               run_time_interval=count_down_time,
                                                                               creator=username)
                suite_task(test_suite_record, test_suite, server_address)
        else:
            print("运行测试集合用例失败")
            return HttpResponse("运行的测试集合为空，请选择测试集合后再运行！")
    case_suites = models.CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = models.TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                models.SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    test_cases = models.SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                models.SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例执行结果-菜单项
@login_required
def test_case_execute_record(request):
    test_case_execute_records = models.TestCaseExecuteResult.objects.filter().order_by('-id')
    return render(request, 'test_case_execute_records.html', {'test_case_execute_records':
                                                                  get_paginator(request, test_case_execute_records)})


# 用例执行结果-对比差异
@login_required
def case_result_diff(request, test_record_id):
    test_record_data = models.TestCaseExecuteResult.objects.get(id=test_record_id)
    print("用例执行结果记录: {}".format(test_record_data))
    present_response = test_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response), sort_keys=True, indent=4,
                                      ensure_ascii=False)  # 中文字符不转ascii编码
        print("当前响应结果: {}".format(present_response))
    last_time_execute_response = test_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True, indent=4,
                                                ensure_ascii=False)
    print("上一次响应结果: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例执行结果-异常信息展示
@login_required
def show_exception(request, execute_id):
    test_record = models.TestCaseExecuteResult.objects.get(id=execute_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果
@login_required
def case_suite_execute_record(request):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.filter().order_by('-id')
    return render(request, 'case_suite_execute_record.html',
                  {'case_suite_execute_records': get_paginator(request, case_suite_execute_record)})


# 用例集合执行结果-包含用例结果展示
@login_required
def suite_case_execute_record(request, suite_record_id):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.get(id=suite_record_id)
    suite_case_execute_records = models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=case_suite_execute_record)
    return render(request, 'suite_case_execute_record.html',
                  {'suite_case_execute_records': get_paginator(request, suite_case_execute_records)})


# 用例集合执行结果-包含用例结果展示-差异比对
@login_required
def suite_case_result_diff(request, suite_case_record_id):
    suite_record_data = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    present_response = suite_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response),sort_keys=True, indent=4, ensure_ascii=False)
        print("当前响应: {}".format(present_response))
    last_time_execute_response = suite_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True,
                                                indent=4, ensure_ascii=False)
    print("上一次响应: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例集合执行结果-包含用例结果展示-异常信息展示
@login_required
def suite_case_exception(request, suite_case_record_id):
    test_record = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果单次统计
def suite_case_statistics(request, suite_id):
    success_num = len(models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id, execute_result="成功"))
    fail_num = len(models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id, execute_result="失败"))
    suite_case_records = models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id).order_by('-id')
    return render(request, 'suite_case_statistics.html',
                  {'suite_case_records': get_paginator(request, suite_case_records), 'success_num': success_num,
                   'fail_num': fail_num})


# 用例集合执行结果历史统计
def case_suite_statistics(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    success_num = len(models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite, test_result="成功"))
    fail_num = len(models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite, test_result="失败"))
    case_suite_records = models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite).order_by('-id')
    return render(request, 'case_suite_statistics.html',
                  {'case_suite_records': get_paginator(request, case_suite_records), 'success_num': success_num,
                   'fail_num': fail_num})


# 模块测试结果统计
@login_required
def module_statistics(request, module_id):
    test_module = models.Module.objects.get(id=int(module_id))
    test_cases = models.TestCase.objects.filter(belong_module=test_module)
    test_suit_success_num = len(
        models.CaseSuiteTestCaseExecuteRecord.objects.filter(test_case__in=test_cases, execute_result="成功"))
    test_suit_fail_num = len(
        models.CaseSuiteTestCaseExecuteRecord.objects.filter(test_case__in=test_cases, execute_result="失败"))
    test_case_success_num = len(
        models.TestCaseExecuteResult.objects.filter(belong_test_case__in=test_cases, execute_result="成功"))
    test_case_fail_num = len(
        models.TestCaseExecuteResult.objects.filter(belong_test_case__in=test_cases, execute_result="失败"))
    success_num = test_suit_success_num + test_case_success_num
    fail_num = test_suit_fail_num + test_case_fail_num
    return render(request, 'module_statistics.html',
                  {'test_module': test_module, 'success_num': success_num, 'fail_num': fail_num})


# 项目测试结果统计
@login_required
def project_statistics(request, project_id):
    test_project = models.Project.objects.get(id=int(project_id))
    test_cases = models.TestCase.objects.filter(belong_project=test_project)
    test_suit_success_num = len(
        models.CaseSuiteTestCaseExecuteRecord.objects.filter(test_case__in=test_cases, execute_result="成功"))
    test_suit_fail_num = len(
        models.CaseSuiteTestCaseExecuteRecord.objects.filter(test_case__in=test_cases, execute_result="失败"))
    test_case_success_num = len(
        models.TestCaseExecuteResult.objects.filter(belong_test_case__in=test_cases, execute_result="成功"))
    test_case_fail_num = len(
        models.TestCaseExecuteResult.objects.filter(belong_test_case__in=test_cases, execute_result="失败"))
    success_num = test_suit_success_num + test_case_success_num
    fail_num = test_suit_fail_num + test_case_fail_num
    return render(request, 'project_statistics.html',
                  {'test_project': test_project, 'success_num': success_num, 'fail_num': fail_num})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

3）定义模板

修改项目页模板 project.html：新增测试结果统计的链接

{% extends 'base.html' %}
{% load static %}
{% block title %}主页{% endblock %}

{% block content %}
<div class="table-responsive">
    <table class="table table-striped">
        <thead>
        <tr>
            <th>id</th>
            <th>项目名称</th>
            <th>项目负责人</th>
            <th>测试负责人</th>
            <th>开发负责人</th>
            <th>简要描述</th>
            <th>创建时间</th>
            <th>更新时间</th>
            <th>测试结果统计</th>
        </tr>
        </thead>
        <tbody>

        {% for project in projects %}
        <tr>
            <td>{{ project.id }}</td>
            <td>{{ project.name }}</td>
            <td>{{ project.proj_owner }}</td>
            <td>{{ project.test_owner }}</td>
            <td>{{ project.dev_owner }}</td>
            <td>{{ project.desc }}</td>
            <td>{{ project.create_time|date:"Y-n-d H:i" }}</td>
            <td>{{ project.update_time|date:"Y-n-d H:i" }}</td>
            <td><a href="{% url 'project_statistics' project.id %}"> 查看</a></td>
        </tr>
        {% endfor %}
        </tbody>
    </table>
</div>

{# 实现分页标签的代码 #}
{# 这里使用 bootstrap 渲染页面 #}
<div id="pages" class="text-center">
    <nav>
        <ul class="pagination">
            <li class="step-links">
                {% if projects.has_previous %}
                <a class='active' href="?page={{ projects.previous_page_number }}">上一页</a>
                {% endif %}

                <span class="current">
                        第 {{ projects.number }} 页 / 共 {{ projects.paginator.num_pages }} 页</span>

                {% if projects.has_next %}
                <a class='active' href="?page={{ projects.next_page_number }}">下一页</a>
                {% endif %}
            </li>
        </ul>
    </nav>
</div>
{% endblock %}

新增项目测试结果统计模板：project_statistics.html

{% extends 'base.html' %}
{% load static %}
{% block title %}模块测试结果统计{% endblock %}
{% block content %}

<style>
    .center{
         width:500px,
         margin-left: 10px;
         background-color: bisque;
         }

</style>
<body>
<p style="margin-left: 10px;">
    <span style="margin-left: 5px;"> 【{{ test_project.name }}】执行统计结果：成功 {{ success_num }} 次，失败 {{ fail_num }} 次</span>
</p>
<p style="margin-left: 10px;">
    <span></span>
</p>
<div class="center" id="main" style="width: 600px; height:400px; margin-left: 10px;" align="center"></div>
<!--<script src="{% static 'js/echarts.simple.min.js' %}"></script>-->
<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/echarts@5/dist/echarts.min.js"></script>
<script>
        // 绘制图表。
        echarts.init(document.getElementById('main')).setOption({
            title: {
                text: '统计结果',
                subtext: '即时数据',
                left: 'center'
            },
            tooltip: {
                trigger: 'item'
            },
            legend: {
               orient: 'vertical',
               left: 'left'
            },
            series: {
                name: '结果统计',
                radius: '55%',
                type: 'pie',
                color: ['green', 'red'],
                data: [
                    {name: '成功用例数', value: {{ success_num }}},
                    {name: '失败用例数', value: {{ fail_num }}},

                ],
                label:{
                        normal:{
                            show:true,
                            formatter: "{b} : {c} ({d}%)"
                        }
                }
            }
        });

</script>
</body>

{% endblock %}

 

16. Celery 异步执行用例

本项目使用 Redis 存储 Celery 的任务执行结果，因此 Redis 需同时启动着。

16.1 Celery 配置

1）定义 celery app：在应用目录下新建 celery.py

from __future__ import absolute_import, unicode_literals
import os
from celery import Celery
from django.conf import settings


# 参数为项目名称
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'InterfaceAutoTest.settings')  # 设置django环境
# 参数为项目名称
app = Celery('InterfaceAutoTest', backend='redis://127.0.0.1:6379/1', broker='redis://127.0.0.1:6379/0')

app.config_from_object('django.conf:settings')  # 使用CELERY_作为前缀，在settings中写配置

app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)  # 发现任务文件每个app下的task.py

# 时区
app.conf.timezone = 'Asia/Shanghai'
# 是否使用UTC
app.conf.enable_utc = False

2）引入 celery app：应用目录下（新建） __init__.py

from __future__ import absolute_import, unicode_literals
from .celery import app as celery_app

__all__ = ['celery_app']

16.2 定义 Celery 任务

在应用下的 task.py 中修改如下代码：把用例执行代码通过装饰器装饰成 celery 任务

from __future__ import absolute_import, unicode_literals
from celery import shared_task
import time
import os
import traceback
import json
from . import models
from .utils.data_process import data_preprocess, assert_result, data_postprocess
from .utils.request_process import request_process


# 测试用例执行
@shared_task
def case_task(test_case_id_list, server_address):
    global_key = 'case'+ str(int(time.time() * 100000))
    os.environ[global_key] = '{}'
    print()
    print("全局变量标识符【global_key】: {}".format(global_key))
    print("全局变量内容【os.environ[global_key]】: {}".format(os.environ[global_key]))
    for test_case_id in test_case_id_list:

        test_case = models.TestCase.objects.filter(id=int(test_case_id))[0]
        last_execute_record_data = models.TestCaseExecuteResult.objects.filter(
            belong_test_case_id=test_case_id).order_by('-id')
        if last_execute_record_data:
            last_time_execute_response_data = last_execute_record_data[0].response_data
        else:
            last_time_execute_response_data = ''
        print("上一次响应结果: {}".format(last_execute_record_data))
        print("上一次响应时间: {}".format(last_time_execute_response_data))
        execute_record = models.TestCaseExecuteResult.objects.create(belong_test_case=test_case)
        execute_record.last_time_response_data = last_time_execute_response_data
        # 获取当前用例上一次执行结果
        execute_record.save()

        test_case = models.TestCase.objects.filter(id=int(test_case_id))[0]
        print("\n######### 开始执行用例【{}】 #########".format(test_case))
        execute_start_time = time.time()  # 记录时间戳，便于计算总耗时（毫秒）
        execute_record.execute_start_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_start_time))

        request_data = test_case.request_data
        extract_var = test_case.extract_var
        assert_key = test_case.assert_key
        interface_name = test_case.uri
        belong_project = test_case.belong_project
        belong_module = test_case.belong_module
        maintainer = test_case.maintainer
        request_method = test_case.request_method
        print("初始请求数据: {}".format(request_data))
        print("关联参数: {}".format(extract_var))
        print("断言关键字: {}".format(assert_key))
        print("接口名称: {}".format(interface_name))
        print("所属项目: {}".format(belong_project))
        print("所属模块: {}".format(belong_module))
        print("用例维护人: {}".format(maintainer))
        print("请求方法: {}".format(request_method))
        url = "{}{}".format(server_address, interface_name)
        print("接口地址: {}".format(url))
        code, request_data, error_msg = data_preprocess(global_key, str(request_data))
        # 请求数据预处理异常，结束用例执行
        if code != 0:
            print("数据处理异常，error: {}".format(error_msg))
            execute_record.execute_result = "失败"
            execute_record.status = 1
            execute_record.exception_info = error_msg
            execute_end_time = time.time()
            execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_end_time))
            execute_record.execute_total_time = int(execute_end_time - execute_start_time) * 1000
            execute_record.save()
            return
        # 记录请求预处理结果
        else:
            execute_record.request_data = request_data
        # 调用接口
        try:
            res_data = request_process(url, request_method, json.loads(request_data))
            print("响应数据: {}".format(json.dumps(res_data.json(), ensure_ascii=False)))  # ensure_ascii：兼容中文
            result_flag, exception_info = assert_result(res_data, assert_key)
            # 结果记录保存
            if result_flag:
                print("用例【%s】执行成功！" % test_case)
                execute_record.execute_result = "成功"
                if extract_var.strip() != "None":
                    var_value = data_postprocess(global_key, json.dumps(res_data.json(), ensure_ascii=False), extract_var)
                    execute_record.extract_var = var_value
            else:
                print("用例【%s】执行失败！" % test_case)
                execute_record.execute_result = "失败"
                execute_record.exception_info = exception_info
            execute_record.response_data = json.dumps(res_data.json(), ensure_ascii=False)
            execute_record.status = 1
            execute_end_time = time.time()
            execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_end_time))
            print("执行结果结束时间: {}".format(execute_record.execute_end_time))
            execute_record.execute_total_time = int((execute_end_time - execute_start_time) * 1000)
            print("用例执行耗时: {}".format(execute_record.execute_total_time))
            execute_record.save()
        except Exception as e:
            print("接口请求异常，error: {}".format(traceback.format_exc()))
            execute_record.execute_result = "失败"
            execute_record.exception_info = traceback.format_exc()
            execute_record.status = 1
            execute_end_time = time.time()
            execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(execute_end_time))
            print("执行结果结束时间: {}".format(execute_record.execute_end_time))
            execute_record.execute_total_time = int(execute_end_time - execute_start_time) * 1000
            print("用例执行耗时: {} 毫秒".format(execute_record.execute_total_time))
            execute_record.save()


# 用例集合执行
@shared_task
def suite_task(case_suite_record, case_suite, server_address):
    global_key = case_suite.suite_desc + str(int(time.time() * 100000))
    # global_vars = {"{}".format(global_key): {}}
    os.environ[global_key] = '{}'
    print("global_key: {}".format(global_key))
    print("os.environ[global_key]: {}".format(os.environ[global_key]))
    case_suite_test_cases = models.SuiteCase.objects.filter(case_suite=case_suite).order_by('id')
    print("用例集合的测试用例列表: {}".format(case_suite_test_cases))
    case_suite_record.test_result = "成功"
    case_suite_record.execute_start_time = time.strftime("%Y-%m-%d %H:%M:%S")

    for case_suite_test_case in case_suite_test_cases:
        test_case = case_suite_test_case.test_case
        print("\n######### 开始执行用例【{}】 #########".format(test_case))
        last_execute_record_data = models.CaseSuiteTestCaseExecuteRecord.objects.filter(
            test_case_id=test_case.id).order_by('-id')
        if last_execute_record_data:
            last_time_execute_response_data = last_execute_record_data[0].response_data
        else:
            last_time_execute_response_data = ''
        print("上一次响应结果: {}".format(last_execute_record_data))
        print("上一次响应时间: {}".format(last_time_execute_response_data))
        suite_case_execute_record = models.CaseSuiteTestCaseExecuteRecord.objects.create(case_suite_record=case_suite_record,
                                                                                  test_case=test_case)
        execute_start_time = time.time()  # 记录时间戳，便于计算总耗时（毫秒）
        suite_case_execute_record.execute_start_time = time.strftime("%Y-%m-%d %H:%M:%S",
                                                                     time.localtime(execute_start_time))
        print("用例集合开始执行时间: {}".format(suite_case_execute_record.execute_start_time))
        suite_case_execute_record.last_time_response_data = last_time_execute_response_data
        suite_case_execute_record.save()
        request_data = test_case.request_data
        extract_var = test_case.extract_var
        assert_key = test_case.assert_key
        interface_name = test_case.uri
        belong_project = test_case.belong_project
        belong_module = test_case.belong_module
        maintainer = test_case.maintainer
        request_method = test_case.request_method
        print("初始请求数据: {}".format(request_data))
        print("关联参数: {}".format(extract_var))
        print("断言关键字: {}".format(assert_key))
        print("接口名称: {}".format(interface_name))
        print("所属项目: {}".format(belong_project))
        print("所属模块: {}".format(belong_module))
        print("用例维护人: {}".format(maintainer))
        print("请求方法: {}".format(request_method))
        url = "{}{}".format(server_address, interface_name)
        print("接口地址: {}".format(url))
        # 请求数据预处理
        code, request_data, error_msg = data_preprocess(global_key, str(request_data))
        # 请求数据预处理异常，结束用例执行
        if code != 0:
            print("数据处理异常，error: {}".format(error_msg))
            suite_case_execute_record.execute_result = "失败"
            suite_case_execute_record.status = 1
            suite_case_execute_record.exception_info = error_msg
            execute_end_time = time.time()
            suite_case_execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S",
                                                                       time.localtime(execute_end_time))
            suite_case_execute_record.execute_total_time = int(execute_end_time - execute_start_time) * 1000
            suite_case_execute_record.save()
            case_suite_record.test_result = "失败"
        # 记录请求预处理的结果
        suite_case_execute_record.request_data = request_data
        try:
            # 调用接口
            res_data = request_process(url, request_method, json.loads(request_data))
            print("响应数据: {}".format(json.dumps(res_data.json(), ensure_ascii=False)))

            result_flag, exception_info = assert_result(res_data, assert_key)
            # 结果记录保存
            if result_flag:
                print("用例【%s】执行成功！" % test_case)
                suite_case_execute_record.execute_result = "成功"
                if extract_var.strip() != "None":
                    var_value = data_postprocess(global_key, json.dumps(res_data.json(), ensure_ascii=False),
                                                 extract_var)
                    suite_case_execute_record.extract_var = var_value
            else:
                print("用例【%s】执行失败！" % test_case)
                suite_case_execute_record.execute_result = "失败"
                suite_case_execute_record.exception_info = exception_info
                case_suite_record.test_result = "失败"
            suite_case_execute_record.response_data = json.dumps(res_data.json(), ensure_ascii=False)
            suite_case_execute_record.status = 1
            execute_end_time = time.time()
            suite_case_execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S",
                                                                       time.localtime(execute_end_time))
            suite_case_execute_record.execute_total_time = int((execute_end_time - execute_start_time) * 1000)
            print("用例执行耗时: {} 毫秒".format(
                suite_case_execute_record.execute_total_time))
            suite_case_execute_record.save()
        except Exception as e:
            print("接口请求异常，error: {}".format(e))
            suite_case_execute_record.execute_result = "失败"
            suite_case_execute_record.exception_info = traceback.format_exc()
            suite_case_execute_record.status = 1
            execute_end_time = time.time()
            suite_case_execute_record.execute_end_time = time.strftime("%Y-%m-%d %H:%M:%S",
                                                                       time.localtime(execute_end_time))
            suite_case_execute_record.execute_total_time = int(execute_end_time - execute_start_time) * 1000
            print("用例集合执行总耗时: {} 毫秒".format(suite_case_execute_record.execute_total_time))
            suite_case_execute_record.save()
            case_suite_record.test_result = "失败"

    case_suite_record.status = 1  # 执行完毕
    case_suite_record.save()

16.3 Celery 启动

在项目目录下执行如下命令（-A 后接应用名称）：

celery worker -A  interfacetestplatform -l info -P eventlet

启动成功日志如下：

需要注意，在 celery 的 task.py 中调用的函数如果有修改，则需要重启 celery。

16.4 Celery 任务执行 

修改用例执行和用例集合执行的视图函数，改为使用 celery 执行的方式。

from django.shortcuts import render, redirect, HttpResponse
from django.contrib import auth  # Django用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator, PageNotAnInteger, InvalidPage
from .form import UserForm
import traceback
import json
from . import models
from .task import case_task, suite_task


# 封装分页处理
def get_paginator(request, data):
    paginator = Paginator(data, 10)  # 默认每页展示10条数据
    # 获取 url 后面的 page 参数的值, 首页不显示 page 参数, 默认值是 1
    page = request.GET.get('page')
    try:
        paginator_pages = paginator.page(page)
    except PageNotAnInteger:
        # 如果请求的页数不是整数, 返回第一页。
        paginator_pages = paginator.page(1)
    except InvalidPage:
        # 如果请求的页数不存在, 重定向页面
        return HttpResponse('找不到页面的内容')
    return paginator_pages


# 项目菜单项
@login_required
def project(request):
    print("request.user.is_authenticated: ", request.user.is_authenticated)
    projects = models.Project.objects.filter().order_by('-id')
    print("projects:", projects)
    return render(request, 'project.html', {'projects': get_paginator(request, projects)})


# 模块菜单项
@login_required
def module(request):
    if request.method == "GET":  # 请求get时候，id倒序查询所有的模块数据
        modules = models.Module.objects.filter().order_by('-id')
        return render(request, 'module.html', {'modules': get_paginator(request, modules)})
    else:  # 否则就是Post请求，会根据输入内容，使用模糊的方式查找所有的项目
        proj_name = request.POST['proj_name']
        projects = models.Project.objects.filter(name__contains=proj_name.strip())
        projs = [proj.id for proj in projects]
        modules = models.Module.objects.filter(belong_project__in=projs)  # 把项目中所有的模块都找出来
        return render(request, 'module.html', {'modules': get_paginator(request, modules), 'proj_name': proj_name})


# 获取测试用例执行的接口地址
def get_server_address(env):
    if env:  # 环境处理
        env_data = models.InterfaceServer.objects.filter(env=env[0])
        print("env_data: {}".format(env_data))
        if env_data:
            ip = env_data[0].ip
            port = env_data[0].port
            print("ip: {}, port: {}".format(ip, port))
            server_address = "http://{}:{}".format(ip, port)
            print("server_address: {}".format(server_address))
            return server_address
        else:
            return ""
    else:
        return ""


# 测试用例菜单项
@login_required
def test_case(request):
    print("request.session['is_login']: {}".format(request.session['is_login']))
    test_cases = ""
    if request.method == "GET":
        test_cases = models.TestCase.objects.filter().order_by('id')
        print("testcases: {}".format(test_cases))
    elif request.method == "POST":
        print("request.POST: {}".format(request.POST))
        test_case_id_list = request.POST.getlist('test_cases_list')
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        if test_case_id_list:
            test_case_id_list.sort()
            print("test_case_id_list: {}".format(test_case_id_list))
            print("获取到用例，开始用例执行")
            # 普通执行
            # case_task(test_case_id_list, server_address)
            # celery 执行
            case_task.apply_async((test_case_id_list, server_address))
        else:
            print("运行测试用例失败")
            return HttpResponse("提交的运行测试用例为空，请选择用例后在提交！")
        test_cases = models.TestCase.objects.filter().order_by('id')
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例详情页
@login_required
def test_case_detail(request, test_case_id):
    test_case_id = int(test_case_id)
    test_case = models.TestCase.objects.get(id=test_case_id)
    print("test_case: {}".format(test_case))
    print("test_case.id: {}".format(test_case.id))
    print("test_case.belong_project: {}".format(test_case.belong_project))

    return render(request, 'test_case_detail.html', {'test_case': test_case})


# 模块页展示测试用例
@login_required
def module_test_cases(request, module_id):
    module = ""
    if module_id:  # 访问的时候，会从url中提取模块的id，根据模块id查询到模块数据，在模板中展现
        module = models.Module.objects.get(id=int(module_id))
    test_cases = models.TestCase.objects.filter(belong_module=module).order_by('-id')
    print("test_case in module_test_cases: {}".format(test_cases))
    return render(request, 'test_case.html', {'test_cases': get_paginator(request, test_cases)})


# 用例集合菜单项
@login_required
def case_suite(request):
    if request.method == "POST":
        count_down_time = 0
        if request.POST['delay_time']:
            print("输入的延迟时间是: {}".format(request.POST['delay_time']))
            try:
                count_down_time = int(request.POST['delay_time'])
            except:
                print("输入的延迟时间是非数字！")
        else:
            print("没有输入延迟时间")
        env = request.POST.getlist('env')
        print("env: {}".format(env))
        server_address = get_server_address(env)
        if not server_address:
            return HttpResponse("提交的运行环境为空，请选择环境后再提交！")
        case_suite_list = request.POST.getlist('case_suite_list')
        if case_suite_list:
            print("所需执行的用例集合列表：", case_suite_list)
            for suite_id in case_suite_list:
                test_suite = models.CaseSuite.objects.get(id=int(suite_id))
                print("所需执行的用例集合: {}".format(test_suite))
                username = request.user.username
                test_suite_record = models.CaseSuiteExecuteRecord.objects.create(case_suite=test_suite,
                                                                               run_time_interval=count_down_time,
                                                                               creator=username)
                # 普通执行
                # suite_task(test_suite_record, test_suite, server_address)
                # celery 执行：countdown表示任务延迟的时间，该参数值可以从前端表单中传递过来
                suite_task.apply_async((test_suite_record, test_suite, server_address), countdown=count_down_time)
        else:
            print("运行测试集合用例失败")
            return HttpResponse("运行的测试集合为空，请选择测试集合后再运行！")
    case_suites = models.CaseSuite.objects.filter()
    return render(request, 'case_suite.html', {'case_suites': get_paginator(request, case_suites)})


# 用例集合-添加测试用例页
@login_required
def add_case_in_suite(request, suite_id):
    # 查询指定的用例集合
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    # 根据id号查询所有的用例
    test_cases = models.TestCase.objects.filter().order_by('id')
    if request.method == "GET":
        print("test cases:", test_cases)
    elif request.method == "POST":
        test_cases_list = request.POST.getlist('testcases_list')
        # 如果页面勾选了用例
        if test_cases_list:
            print("勾选用例id：", test_cases_list)
            # 根据页面勾选的用例与查询出的所有用例一一比较
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                # 匹配成功则添加用例
                models.SuiteCase.objects.create(case_suite=case_suite, test_case=test_case)
        # 未勾选用例
        else:
            print("添加测试用例失败")
            return HttpResponse("添加的测试用例为空，请选择用例后再添加！")
    return render(request, 'add_case_in_suite.html',
          {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例集合页-查看/删除用例
@login_required
def show_and_delete_case_in_suite(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    test_cases = models.SuiteCase.objects.filter(case_suite=case_suite)
    if request.method == "POST":
        test_cases_list = request.POST.getlist('test_cases_list')
        if test_cases_list:
            print("勾选用例：", test_cases_list)
            for test_case in test_cases_list:
                test_case = models.TestCase.objects.get(id=int(test_case))
                models.SuiteCase.objects.filter(case_suite=case_suite, test_case=test_case).first().delete()
        else:
            print("测试用例删除失败")
            return HttpResponse("所选测试用例为空，请选择用例后再进行删除！")
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    return render(request, 'show_and_delete_case_in_suite.html',
                  {'test_cases': get_paginator(request, test_cases), 'case_suite': case_suite})


# 用例执行结果-菜单项
@login_required
def test_case_execute_record(request):
    test_case_execute_records = models.TestCaseExecuteResult.objects.filter().order_by('-id')
    return render(request, 'test_case_execute_records.html', {'test_case_execute_records':
                                                                  get_paginator(request, test_case_execute_records)})


# 用例执行结果-对比差异
@login_required
def case_result_diff(request, test_record_id):
    test_record_data = models.TestCaseExecuteResult.objects.get(id=test_record_id)
    print("用例执行结果记录: {}".format(test_record_data))
    present_response = test_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response), sort_keys=True, indent=4,
                                      ensure_ascii=False)  # 中文字符不转ascii编码
        print("当前响应结果: {}".format(present_response))
    last_time_execute_response = test_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True, indent=4,
                                                ensure_ascii=False)
    print("上一次响应结果: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例执行结果-异常信息展示
@login_required
def show_exception(request, execute_id):
    test_record = models.TestCaseExecuteResult.objects.get(id=execute_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果
@login_required
def case_suite_execute_record(request):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.filter().order_by('-id')
    return render(request, 'case_suite_execute_record.html',
                  {'case_suite_execute_records': get_paginator(request, case_suite_execute_record)})


# 用例集合执行结果-包含用例结果展示
@login_required
def suite_case_execute_record(request, suite_record_id):
    case_suite_execute_record = models.CaseSuiteExecuteRecord.objects.get(id=suite_record_id)
    suite_case_execute_records = models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=case_suite_execute_record)
    return render(request, 'suite_case_execute_record.html',
                  {'suite_case_execute_records': get_paginator(request, suite_case_execute_records)})


# 用例集合执行结果-包含用例结果展示-差异比对
@login_required
def suite_case_result_diff(request, suite_case_record_id):
    suite_record_data = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    present_response = suite_record_data.response_data
    if present_response:
        present_response = json.dumps(json.loads(present_response),sort_keys=True, indent=4, ensure_ascii=False)
        print("当前响应: {}".format(present_response))
    last_time_execute_response = suite_record_data.last_time_response_data
    if last_time_execute_response:
        last_time_execute_response = json.dumps(json.loads(last_time_execute_response), sort_keys=True,
                                                indent=4, ensure_ascii=False)
    print("上一次响应: {}".format(last_time_execute_response))
    return render(request, 'case_result_diff.html', locals())


# 用例集合执行结果-包含用例结果展示-异常信息展示
@login_required
def suite_case_exception(request, suite_case_record_id):
    test_record = models.CaseSuiteTestCaseExecuteRecord.objects.get(id=suite_case_record_id)
    return render(request, 'show_exception.html', {'exception_info': test_record.exception_info})


# 用例集合执行结果单次统计
def suite_case_statistics(request, suite_id):
    success_num = len(models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id, execute_result="成功"))
    fail_num = len(models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id, execute_result="失败"))
    suite_case_records = models.CaseSuiteTestCaseExecuteRecord.objects.filter(case_suite_record=suite_id).order_by('-id')
    return render(request, 'suite_case_statistics.html',
                  {'suite_case_records': get_paginator(request, suite_case_records), 'success_num': success_num,
                   'fail_num': fail_num})


# 用例集合执行结果历史统计
def case_suite_statistics(request, suite_id):
    case_suite = models.CaseSuite.objects.get(id=suite_id)
    success_num = len(models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite, test_result="成功"))
    fail_num = len(models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite, test_result="失败"))
    case_suite_records = models.CaseSuiteExecuteRecord.objects.filter(case_suite=case_suite).order_by('-id')
    return render(request, 'case_suite_statistics.html',
                  {'case_suite_records': get_paginator(request, case_suite_records), 'success_num': success_num,
                   'fail_num': fail_num})


# 模块测试结果统计
@login_required
def module_statistics(request, module_id):
    test_module = models.Module.objects.get(id=int(module_id))
    test_cases = models.TestCase.objects.filter(belong_module=test_module)
    test_suit_success_num = len(
        models.CaseSuiteTestCaseExecuteRecord.objects.filter(test_case__in=test_cases, execute_result="成功"))
    test_suit_fail_num = len(
        models.CaseSuiteTestCaseExecuteRecord.objects.filter(test_case__in=test_cases, execute_result="失败"))
    test_case_success_num = len(
        models.TestCaseExecuteResult.objects.filter(belong_test_case__in=test_cases, execute_result="成功"))
    test_case_fail_num = len(
        models.TestCaseExecuteResult.objects.filter(belong_test_case__in=test_cases, execute_result="失败"))
    success_num = test_suit_success_num + test_case_success_num
    fail_num = test_suit_fail_num + test_case_fail_num
    return render(request, 'module_statistics.html',
                  {'test_module': test_module, 'success_num': success_num, 'fail_num': fail_num})


# 项目测试结果统计
@login_required
def project_statistics(request, project_id):
    test_project = models.Project.objects.get(id=int(project_id))
    test_cases = models.TestCase.objects.filter(belong_project=test_project)
    test_suit_success_num = len(
        models.CaseSuiteTestCaseExecuteRecord.objects.filter(test_case__in=test_cases, execute_result="成功"))
    test_suit_fail_num = len(
        models.CaseSuiteTestCaseExecuteRecord.objects.filter(test_case__in=test_cases, execute_result="失败"))
    test_case_success_num = len(
        models.TestCaseExecuteResult.objects.filter(belong_test_case__in=test_cases, execute_result="成功"))
    test_case_fail_num = len(
        models.TestCaseExecuteResult.objects.filter(belong_test_case__in=test_cases, execute_result="失败"))
    success_num = test_suit_success_num + test_case_success_num
    fail_num = test_suit_fail_num + test_case_fail_num
    return render(request, 'project_statistics.html',
                  {'test_project': test_project, 'success_num': success_num, 'fail_num': fail_num})


# 默认页的视图函数
@login_required
def index(request):
    return render(request, 'index.html')


# 登录页的视图函数
def login(request):
    print("request.session.items(): {}".format(request.session.items()))  # 打印session信息
    if request.session.get('is_login', None):
        return redirect('/')
    # 如果是表单提交行为，则进行登录校验
    if request.method == "POST":
        login_form = UserForm(request.POST)
        message = "请检查填写的内容！"
        if login_form.is_valid():
            username = login_form.cleaned_data['username']
            password = login_form.cleaned_data['password']
            try:
                # 使用django提供的身份验证功能
                user = auth.authenticate(username=username, password=password)  # 从auth_user表中匹配信息，匹配到则返回用户对象
                if user is not None:
                    print("用户【%s】登录成功" % username)
                    auth.login(request, user)
                    request.session['is_login'] = True
                    # 登录成功，跳转主页
                    return redirect('/')
                else:
                    message = "用户名不存在或者密码不正确！"
            except:
                traceback.print_exc()
                message = "登录程序出现异常"
        # 用户名或密码为空，返回登录页和错误提示信息
        else:
            return render(request, 'login.html', locals())
    # 不是表单提交，代表只是访问登录页
    else:
        login_form = UserForm()
        return render(request, 'login.html', locals())


# 注册页的视图函数
def register(request):
    return render(request, 'register.html')


# 登出的视图函数：重定向至login视图函数
@login_required
def logout(request):
    auth.logout(request)
    request.session.flush()
    return redirect("/login/")

页面勾选用例/集合提交运行，在 celery 命令行界面，查看用例运行结果，如下所示：