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

简介: 上一章,咱们对http请求进行了一些优化,本章节我们将组成场景去运行。首先场景就是一连串的http接口的请求,我们使用list(列表)来组装成一个场景

上一章,咱们对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/

        }

}

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

相关文章
|
27天前
|
资源调度 测试技术 Linux
一款接口自动化神器—开源接口测试平台Lim(Less is More)
一款接口自动化神器—开源接口测试平台Lim(Less is More)
61 2
|
2月前
|
前端开发 测试技术
可访问性测试清单/测试用例/场景
可访问性测试清单/测试用例/场景
可访问性测试清单/测试用例/场景
|
2月前
|
域名解析 JSON 测试技术
常见移动端APP测试场景
常见移动端APP测试场景
|
27天前
|
测试技术
Lim测试平台测试报告说明
Lim测试平台测试报告说明
28 2
|
27天前
|
SQL 测试技术 数据库连接
Lim接口测试平台-接口测试功能详解
Lim接口测试平台-接口测试功能详解
23 1
|
27天前
|
SQL 监控 测试技术
Lim测试平台变量使用规则介绍
Lim测试平台变量使用规则介绍
17 0
|
27天前
|
测试技术
使用Lim测试平台快速完成批量造数
使用Lim测试平台快速完成批量造数
15 1
|
27天前
|
SQL JSON 监控
Lim测试平台快速上手教程
Lim测试平台快速上手教程
19 0
|
1月前
|
测试技术 Linux 数据安全/隐私保护
如何远程访问Linux MeterSphere一站式开源持续测试平台
MeterSphere 是一站式开源持续测试平台, 涵盖测试跟踪、接口测试、UI 测试和性能测试等功能,全面兼容 JMeter、Selenium 等主流开源标准,有效助力开发和测试团队充分利用云弹性进行高度可扩展的自动化测试,加速高质量的软件交付,推动中国测试行业整体效率的提升。
|
1月前
|
Web App开发 传感器 Android开发
APP兼容性测试都需要考虑哪些场景?
APP兼容性测试都需要考虑哪些场景?

相关产品

  • 云迁移中心