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 命令列介面，檢視用例執行結果，如下所示：