【测试平台系列】第一章手撸压力机（八）- 实现testobject接口-阿里云开发者社区

上一章中我们已经启动了一个/engine/run/testObject/接口，但是我们还没有具体的实现该接口，本章我们就来实现一下该接口。

首先，我们在global目录下新建common/response.go，我们在response.go文件中定义好/engine/run/testObject/接口的响应信息。


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

import "github.com/gin-gonic/gin"

// Response 定义一个响应体，当请求我们的接口时，返回使用
type Response struct {
  Code    int32       `json:"code"`    // 响应码
  Id      string      `json:"id"`      // 唯一id
  Message string      `json:"message"` // 消息
  Data    interface{} `json:"data"`    // 具体信息
}


/*
  返回响应信息，使用ctx.Json返回json数据
*/

func ReturnResponse(ctx *gin.Context, code int32, id string, msg string, data interface{}) {
  ctx.JSON(
    200,
    Response{
      code,
      id,
      msg,
      data,
    })
}

然后，我们在model/test_object.go中定义一个接口体接收我们发送的请求的请求及响应信息。test_object.go全部代码如下：



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

// TestObjectResponse 响应信息， 用于返回给调用方
type TestObjectResponse struct {
  Name            string            `json:"name"`         // 对象名称
  Id              string            `json:"id"`           // 唯一id
  ParentId        string            `json:"parent_id"`    // 父id
  ObjectType      string            `json:"object_type"`  // 对象类型http、websocket、dubbo等
  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"` // 渠道类型
  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"`
}

// TestObject 测试对象结构体
type TestObject struct {
  Name        string      `json:"name"`         // 对象名称
  Id          string      `json:"id"`           // 唯一id
  ParentId    string      `json:"parent_id"`    // 父id
  ObjectType  string      `json:"object_type"`  // 对象类型http、websocket、dubbo等
  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"` // 渠道类型
  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
}

上述代码中，大家可以我们把Dispose函数进行了优化：

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


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

在现代码中，我们首先给Dispose函数加了个TestObjectResponse的指针参数，其次，我们将client.RequestHttp函数修改为HttpRequest.Request方法。现在，我们将client目录删除（包括http_client.go文件）。然后我们修改model/http_request.go文件如下：


package model

import (
  "crypto/tls"
  "crypto/x509"
  "fmt"
  "github.com/valyala/fasthttp"
  "io/ioutil"
  "kitchen-engine/global/log"
  "strings"
  "time"
)

// HttpRequest http请求的结构
type HttpRequest struct {
  Url                string             `json:"url"`                  // 接口uri
  Method             string             `json:"method"`               // 接口方法，Get Post Update...
  Headers            []Header           `json:"headers"`              // 接口请求头
  Querys             []Query            `json:"querys"`               // get请求时的url
  Cookies            []Cookie           `json:"cookies"`              // cookie
  Body               string             `json:"body"`                 // 请求提
  HttpClientSettings HttpClientSettings `json:"http_client_settings"` // http客户端配置
}

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)

  // 添加该请求的http方法：get、post、delete、update等等
  req.Header.SetMethod(hr.Method)

  // 设置header
  for _, header := range hr.Headers {
    if strings.EqualFold(header.Field, "host") {
      // 由于在header中设置host不生效，所以需要强制设置生效
      req.SetHost(header.Value)
      req.UseHostHeader = true
    } else {
      req.Header.Add(header.Field, header.Value)
    }

  }

  // 设置cookie
  for _, cookie := range hr.Cookies {
    req.Header.SetCookie(cookie.Field, cookie.Value)
  }

  // 如果query不为空则设置query
  urlQuery := req.URI().QueryArgs()
  for _, query := range hr.Querys {
    if !strings.Contains(hr.Url, query.Field) {
      queryBy := []byte(query.Value)
      urlQuery.AddBytesV(query.Field, queryBy)
      hr.Url += fmt.Sprintf("&%s=%s", query.Field, query.Value)
    }
  }

  req.SetBody([]byte(hr.Body))
  // 添加该请求的http的url
  req.SetRequestURI(hr.Url)

  // 记录开始时间
  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
  }
  log.Logger.Debug("resp:    ", string(resp.Body()))
  response.Response = string(resp.Body())

}

// 新建一个http客户端
func newHttpClient(httpClientSettings HttpClientSettings) (httpClient *fasthttp.Client) {
  // tls验证，关闭验证
  tr := &tls.Config{
    InsecureSkipVerify: true,
  }
  // 新建指针类型的客户端
  httpClient = &fasthttp.Client{}

  if httpClientSettings.Name != "" {
    httpClient.Name = httpClientSettings.Name
  }

  if httpClientSettings.NoDefaultUserAgentHeader == true {
    httpClient.NoDefaultUserAgentHeader = true
  }

  // 如果最大连接数不为0，将设置此数
  if httpClientSettings.MaxConnsPerHost != 0 {
    httpClient.MaxConnsPerHost = httpClientSettings.MaxConnsPerHost
  }

  // url不按照标准输出，按照原样输出
  if httpClientSettings.DisablePathNormalizing == true {
    httpClient.DisablePathNormalizing = true
  }
  // 请求头不按标准格式传输
  if httpClientSettings.DisableHeaderNamesNormalizing == true {
    httpClient.DisableHeaderNamesNormalizing = true
  }

  // 如果此时间不为0，那么将设置此时间。keep-alive维持此时长后将关闭。时间单位为毫秒
  if httpClientSettings.MaxConnDuration != 0 {
    httpClient.MaxConnDuration = time.Duration(httpClientSettings.MaxConnDuration) * time.Millisecond
  }

  if httpClientSettings.ReadTimeout != 0 {
    httpClient.ReadTimeout = time.Duration(httpClientSettings.ReadTimeout) * time.Millisecond
  }

  if httpClientSettings.WriteTimeout != 0 {
    httpClient.WriteTimeout = time.Duration(httpClientSettings.WriteTimeout) * time.Millisecond
  }

  // 该连接如果空闲的话，在此时间后断开。
  if httpClientSettings.MaxIdleConnDuration != 0 {
    httpClient.MaxIdleConnDuration = time.Duration(httpClientSettings.MaxIdleConnDuration) * time.Millisecond
  }

  //
  httpsTls := httpClientSettings.AdvancedOptions.Tls

  // 如果开启认证
  if httpsTls.IsVerify {
    // switch条件选择语句，如果认证类型为0：则表示双向认证，如果是1：则表示为单向认证
    switch httpsTls.VerifyType {
    case 0: // 开启双向验证
      tr.InsecureSkipVerify = false
      // 如果密钥文件为空则跳出switch语句
      if httpsTls.CaCert == "" {
        break
      }
      // 生成一个cert对象池
      caCertPool := x509.NewCertPool()
      if caCertPool == nil {
        fmt.Println("生成CertPool失败！")
        break
      }

      // 读取认证文件，读出后为字节
      key, err := ioutil.ReadFile(httpsTls.CaCert)
      // 如果读取错误，则跳出switch语句
      if err != nil {
        fmt.Println("打开密钥文件失败：", err.Error())
        break
      }
      // 将认证文件添加到cert池中
      ok := caCertPool.AppendCertsFromPEM(key)
      // 如果添加失败则跳出switch语句
      if !ok {
        fmt.Println("密钥文件错误，生成失败！！！")
        break
      }
      // 将认证信息添加到客户端认证结构体
      tr.ClientCAs = caCertPool
    case 1: // 开启单向验证，客户端验证服务端密钥
      tr.InsecureSkipVerify = false
    }
  }

  fmt.Println("tr:    ", tr.InsecureSkipVerify)
  // 客户端认证配置项
  httpClient.TLSConfig = tr
  return
}

// Header header
type Header struct {
  Field     string `json:"field"`      // 字段名称
  Value     string `json:"value"`      // 字段值
  FieldType string `json:"field_type"` // 字段类型
}

// Query query
type Query struct {
  Field     string `json:"field"`
  Value     string `json:"value"`
  FieldType string `json:"field_type"`
}

// Cookie cookie
type Cookie struct {
  Field     string `json:"field"`
  Value     string `json:"value"`
  FieldType string `json:"field_type"`
}

type HttpClientSettings struct {
  //  客户端的名称，在header中的user-agent使用，通常我们默认就好
  Name string `json:"name"`

  // 默认为flase，表示User-Agent使用fasthttp的默认值
  NoDefaultUserAgentHeader bool `json:"no_default_user_agent_header"`

  // 每台主机可以建立的最大连接数。如果没有设置，则使用DefaultMaxConnsPerHost。
  MaxConnsPerHost int `json:"max_conns_per_host"`

  // 空闲的保持连接在此持续时间之后关闭。默认情况下，在DefaultMaxIdleConnDuration之后关闭空闲连接。
  // 该连接如果空闲的话，在此时间后断开。
  MaxIdleConnDuration int64 `json:"max_idle_conn_duration"`

  // Keep-alive连接在此持续时间后关闭。默认情况下，连接时间是不限制的。
  MaxConnDuration int `json:"max_conn_duration"`

  // 默认情况下，响应读取超时时间是不限制的。
  ReadTimeout int64 `json:"read_timeout"`
  // 默认情况下，请求写超时时间不受限制。
  WriteTimeout int64 `json:"write_timeout"`

  // 请求头是否按标准格式传输
  DisableHeaderNamesNormalizing bool `json:"disable_header_names_normalizing"`
  // url路径是按照原样输出，还是按照规范化输出。默认按照规范化输出
  DisablePathNormalizing bool            `json:"disable_path_normalizing"`
  AdvancedOptions        AdvancedOptions `json:"advanced_options"` // 高级选项
}

// AdvancedOptions 高级选项
type AdvancedOptions struct {
  Tls Tls `json:"tls"` // 验证设置
}

// Tls tls认证结构体
type Tls struct {
  IsVerify   bool   `json:"is_verify"`   // 是否开启验证，默认不开启，开启后需要上传密钥文件
  VerifyType int32  `json:"verify_type"` // 认证类型：0表示双向认证；1表示单向认证；默认为0
  CaCert     string `json:"ca_cert"`     // 密钥文件
}

再在我们项目的根目录新建service/api.go，我们定义RunTestObject方法来实现我们的接口。


// Package service -----------------------------
// @file      : 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,
    ParentId:    testObject.ParentId,
    ObjectType:  testObject.ObjectType,
    ItemId:      testObject.ItemId,
    SourceId:    testObject.SourceId,
    ChannelId:   testObject.ChannelId,
    ChannelType: testObject.ChannelType,
  }

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

main.go如下：


func main() {
  log.Logger.Debug("yc:   ", config.YC)
  runService()
  log.Logger.Info("欢迎使用zap日志")
}

启动项目。然后我们使用其他接口测试工具对我们的接口进行调试。


method: POST
url: http:127.0.0.1:8003/engine/run/testObject/
body: 
{
    "name": "百度",
    "id": "12312312",
    "parent_id": "",
    "object_type": "HTTP1.1",
    "item_id": "",
    "http_request": {
        "url": "http://www.baidu.com",
        "method": "GET"
    }

}

响应信息如下：


{
  "code": 200,
  "id": "b531a6db-ba65-4bb4-b9cb-fb252a210996",
  "message": "请求成功！",
  "data": {
    "name": "百度",
    "id": "12312312",
    "parent_id": "",
    "object_type": "HTTP1.1",
    "item_id": "",
    "team_id": "",
    "source_id": "",
    "channel_id": "",
    "channel_type": "",
    "code": 200,
    "request_headers": null,
    "response_headers": null,
    "response": "***全球领先的中文搜索引擎、致力于让网民更便捷地获取信息，找到所求。百度超过千亿的中文网页数据库，可以瞬间找到相关的搜索结果***"
  }
}

【测试平台系列】第一章手撸压力机（八）- 实现testobject接口

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【测试平台系列】第一章 手撸压力机（八）- 实现testobject接口