【测试平台系列】第一章 手撸压力机（十）-定义场景

上一章，咱们对http请求进行了一些优化，本章节我们将组成场景去运行。首先场景就是一连串的http接口的请求，我们使用list（列表）来组装成一个场景。
首先我们在model目录下，新建test_scene.go文件。

// Package model -----------------------------
// @file      : test_scene.go
// @author    : 被测试耽误的大厨
// @contact   : 13383088061@163.com
// @time      : 2023/7/6 15:53
// -------------------------------------------
package model

import "sync"

// TestScene 业务流程组成的测试场景
type TestScene struct {
        Name        string       `json:"name"`         // 场景名称
        Id          string       `json:"id"`           // 唯一id
        ParentId    string       `json:"parent_id"`    // 父id
        ItemId      string       `json:"item_id"`      // 项目Id
        TeamId      string       `json:"team_id"`      // 团队Id
        SourceId    string       `json:"source_id"`    // 源Id
        ChannelId   string       `json:"channel_id"`   // 渠道Id比如YApi，postman等
        ChannelType string       `json:"channel_type"` // 渠道类型
        TestObjects []TestObject `json:"test_objects"` // 场景
}

/*
 处理测试场景
*/

func (testScene TestScene) Dispose() {
        // 从testScene.TestObjects的最外层开始循环
        for _, testObject := range testScene.TestObjects {
                // 声明一个waitGroup控制等待内层循环请求内部完成
                wg := sync.WaitGroup{}
                // 从一层级的list中读取每个TestObject对象
                wg.Add(1)
                go func(object TestObject) {
                        defer wg.Done()
                        response := TestObjectResponse{
                                Name:        object.Name,
                                Id:          object.Id,
                                SceneId:     testScene.Id,
                ItemId:      object.ItemId，
                                ObjectType:  object.ObjectType,

                        }
                        // 开始进行请求处理
                        object.Dispose(&response)
                }(testObject)
                // 等待内层的list完成后，再开始下一次外层循环
                wg.Wait()
        }
}

上面的内容，我们定义了一个TestScene结构体，来表示我们的测试场景，然后定义了TestScene的结构体来处理场景。
然后我们新建一个reponse_data.go文件，用来声明我们需要的测试结果信息

// Package model -----------------------------
// @file      : response_data.go
// @author    : 被测试耽误的大厨
// @contact   : 13383088061@163.com
// @time      : 2023/7/6 16:21
// -------------------------------------------
package model

// TestObjectResponse 响应信息， 用于返回给调用方
type TestObjectResponse struct {
        Name            string            `json:"name"`         // 对象名称
        Id              string            `json:"id"`           // 对象id
        SceneId         string            `json:"scene_id"`     // 场景id
        ObjectType      string            `json:"object_type"`  // 对象类型http、websocket、dubbo等
        ItemId          string            `json:"item_id"`      // 项目Id
        TeamId          string            `json:"team_id"`      // 团队Id
        Code            int               `json:"code"`
        RequestHeaders  map[string]string `json:"request_headers"`
        ResponseHeaders map[string]string `json:"response_headers"`
        Response        string            `json:"response"`
        RequestTime     int64             `json:"request_time"`
}

我们将原来test_object.go中的结构体单独提取到reponse_data.go文件中，并对一些无用的字段进行优化。

// Package model -----------------------------
// @file      : test_object.go
// @author    : 被测试耽误的大厨
// @contact   : 13383088061@163.com
// @time      : 2023/6/11 20:38
// -------------------------------------------
package model

// TestObject 测试对象结构体
type TestObject struct {
        Name        string      `json:"name"`        // 对象名称
        Id          string      `json:"id"`          // 唯一id
        ObjectType  string      `json:"object_type"` // 对象类型http、websocket、dubbo等
        ItemId      string      `json:"item_id"`     // 项目Id
        TeamId      string      `json:"team_id"`     // 团队Id
        HttpRequest HttpRequest `json:"http_request"`
}

// Dispose 测试对象的处理函数，在go语言中 Dispose方法是TestObject对象的方法，其他对象不能使用
func (to TestObject) Dispose(response *TestObjectResponse) {
        switch to.ObjectType {
        case HTTP1: // 由于我们有个多类型，为了方便统计，我们定义好变量，直接进行比对即可
                to.HttpRequest.Request(response)
                return
        }
        return
}

然后我们在service目录下新建scene_api.go文件，新建RunTestScene方法来实现请求读取。

// Package service -----------------------------
// @file      : scene_api.go
// @author    : 被测试耽误的大厨
// @contact   : 13383088061@163.com
// @time      : 2023/7/6 16:06
// -------------------------------------------
package service

import (
        "encoding/json"
        "fmt"
        "github.com/gin-gonic/gin"
        "github.com/google/uuid"
        "kitchen-engine/global/common"
        "kitchen-engine/global/log"
        "kitchen-engine/model"
        "net/http"
)

/*
        RunTestScene 实现run/testObject/接口
*/

func RunTestScene(c *gin.Context) {

        // 声明一个TO对象
        var testScene model.TestScene

        // 接收json格式的请求数据
        err := c.ShouldBindJSON(&testScene)
        id := uuid.New().String()
        // 如果请求格式错误
        if err != nil {
                log.Logger.Error("请求数据格式错误", err.Error())
                common.ReturnResponse(c, http.StatusBadRequest, id, "请求数据格式错误！", err.Error())
                return
        }

        // 使用json包解析以下TO对象, 解析出来为[]byte类型
        requestJson, _ := json.Marshal(testScene)
        // 打印以下日志, 使用fmt.Sprintf包格式花数据，%s 表示string(requestJson)为字符串类型，如果不确定类型，可以使用%v表示
        log.Logger.Debug(fmt.Sprintf("测试对象： %s", string(requestJson)))

        // 如果场景为空，直接返回
        if testScene.TestObjects == nil || len(testScene.TestObjects) == 0 {
                common.ReturnResponse(c, http.StatusBadRequest, id, "请求错误！", "场景不能为空")
                return
        }

        // 开始处理TO
        testScene.Dispose()
        // 返回响应消息
        common.ReturnResponse(c, http.StatusOK, id, "请求成功！", "")
        return
}

同时，将service目录下的api.go更名为object_api.go，并对其中的无用字段进行优化：

// Package service -----------------------------
// @file      : object_api.go
// @author    : 被测试耽误的大厨
// @contact   : 13383088061@163.com
// @time      : 2023/7/4 18:05
// -------------------------------------------
package service

import (
        "encoding/json"
        "fmt"
        "github.com/gin-gonic/gin"
        "github.com/google/uuid"
        "kitchen-engine/global/common"
        "kitchen-engine/global/log"
        "kitchen-engine/model"
        "net/http"
)

/*
        RunTestObject 实现run/testObject/接口
*/

func RunTestObject(c *gin.Context) {

        // 声明一个TO对象
        var testObject model.TestObject

        // 接收json格式的请求数据
        err := c.ShouldBindJSON(&testObject)
        id := uuid.New().String()
        // 如果请求格式错误
        if err != nil {
                log.Logger.Error("请求数据格式错误", err.Error())
                common.ReturnResponse(c, http.StatusBadRequest, id, "请求数据格式错误！", err.Error())
                return
        }

        // 使用json包解析以下TO对象, 解析出来为[]byte类型
        requestJson, _ := json.Marshal(testObject)
        // 打印以下日志, 使用fmt.Sprintf包格式花数据，%s 表示string(requestJson)为字符串类型，如果不确定类型，可以使用%v表示
        log.Logger.Debug(fmt.Sprintf("测试对象： %s", string(requestJson)))

        response := model.TestObjectResponse{
                Name:       testObject.Name,
                Id:         testObject.Id,
                ObjectType: testObject.ObjectType,
                ItemId:     testObject.ItemId,
        }

        // 开始处理TO
        testObject.Dispose(&response)
        // 返回响应消息
        common.ReturnResponse(c, http.StatusOK, id, "请求成功！", response)
        return
}

我们再对Http请求添加一个timeout字段，并在发送请求是设置超时时间。

// HttpRequest http请求的结构
type HttpRequest struct {
        Url                string             `json:"url"`                  // 接口uri
        Method             string             `json:"method"`               // 接口方法，Get Post Update...
        RequestTimeout     int64              `json:"request_timeout"`      // 请求超时时长，默认为30秒，防止请求阻塞
        Headers            []Header           `json:"headers"`              // 接口请求头
        Querys             []Query            `json:"querys"`               // get请求时的url
        Cookies            []Cookie           `json:"cookies"`              // cookie
        Body               *Body              `json:"body"`                 // 请求提
        HttpClientSettings HttpClientSettings `json:"http_client_settings"` // http客户端配置
}
在http_request.go文件中，新建HttpRequest结构体的setReqTime方法
// 设置请求超时时间
func (hr *HttpRequest) setReqTimeout(req *fasthttp.Request) {
        if hr.RequestTimeout <= 0 {
                hr.RequestTimeout = 30
        }
        req.SetTimeout(time.Duration(hr.RequestTimeout) * time.Second)
}

并对HttpRequest结构体的Request方法进行优化
func (hr *HttpRequest) Request(response *TestObjectResponse) {

        // 使用fasthttp 协程池

        // 新建一个http请求
        req := fasthttp.AcquireRequest()
        defer fasthttp.ReleaseRequest(req)
        // 新建一个http响应接受服务端的返回
        resp := fasthttp.AcquireResponse()
        defer fasthttp.ReleaseResponse(resp)

        // 新建一个http的客户端, newHttpClient是一个方法，在下面
        client := newHttpClient(hr.HttpClientSettings)

        // 设置请求方法
        hr.methodInit(req)

        // 设置header
        hr.headerInit(req)
        // 设置query
        hr.queryInit(req)
        // 设置cookie
        hr.cookieInit(req)

        // 设置url
        hr.urlInit(req)

        // 设置body
        hr.bodyInit(req)

        // 设置请求超时时间
        hr.setReqTimeout(req)

        // 记录开始时间
        startTime := time.Now()
        // 开始请求
        err := client.Do(req, resp)
        // 计算响应时间差值
        requestTime := time.Since(startTime)
        response.RequestTime = requestTime.Milliseconds()
        response.Code = resp.StatusCode()
        if err != nil {
                response.Response = err.Error()
                return
        }

        // 如果响应中有压缩类型,防止压缩类型出现乱码
        switch string(resp.Header.ContentEncoding()) {
        case "br", "deflate", "gzip":
                b, _ := resp.BodyUncompressed()
                response.Response = string(b)
        default:
                response.Response = string(resp.Body())
        }

}

同时，我们添加run/testScene接口，修改router.go中的initRouters方法。

/*
  路由配置
*/
func initRouters(groups *gin.RouterGroup) {
        {
                groups.POST("/run/testObject/", service.RunTestObject) //运行测试对象接口， url: http://*****/engine/run/testObject/
                groups.POST("/run/testScene/", service.RunTestScene)   //运行测试对象接口， url: http://*****/engine/run/testObject/

        }

}

这样，我们对场景的简单封装就完成了，下一步我们将对场景以及请求进行更全面的适配。