碼上歡樂
相關內容    簡體    繁體

【Golang】基於錄制，自動生成go test接口自動化用例

本文轉載自   查看原文   2019-03-12 14:08   781    Golang/ Golang自動化/ 數據驅動/ 03. Golang 接口自動化/ 09. Golang/ GO/ 接口自動化/ 01. 不向靜中參妙理/ 縱然穎悟也虛浮/ go test/ 自動生成測試用例

背景

之前寫過一篇博客，介紹怎么用Python通過解析抓包數據，完成自動化用例的編寫。最近這段時間在使用go test，所以就在想能不能也使用代碼來生成自動化用例，快速提升測試用例覆蓋率。說干就干。

框架

首先介紹一下我們使用的測框架：

項 信息 安裝 備注
GO版本 go1.12.9 darwin/amd64 略
測試框架 ginkgo go get -u github.com/onsi/ginkgo/ginkgo
斷言庫 testify/assert go get github.com/stretchr/testify 官方配套的斷言庫是gomega

ginkgo初始化

  • 初始化: cd path/to/package/you/want/to/test && ginkgo bootstrap
  • 創建示例用例：ginkgo generate (需要手動添加測試用例)
  • 運行測試： go testor ginkgo

注：-v加上參數可打印運行信息

抓包&運行腳本

  • 使用抓包工具（如Charles）抓包，把數據包導出為har格式，保存在當前目錄下
    • 如何安裝抓包工具在本文就不贅述了，抓包，過濾出想要的數據，導出，保存的格式注意選擇為har：
  • 根據實際情況修改全局變量信息，如bizBaseFolder、serverName、userFile等
  • 使用go run gentest.go運行腳本即可

目錄說明

然后我們一起來了解一下我們的目錄結構定義。

∮./business

業務封裝，封裝具體的請求及測試數據

∮./conf

配置信息及接口請求參數初始化封裝

∮./utils

公共函數封裝

∮./testcase

接口測試用例目錄

testcase 用例目錄結構規則

基本原則： 根據項目、模塊、接口功能逐級區分，建議最多3層目錄層級

¶示例
  1. 軟件測試論壇項目組/論壇項目/帖子模塊/創建帖子接口：
    • CN_TestBBS/bbs/post/post_test.go
  2. 基礎賬號項目/首頁項目/白名單接口：
    • CN_account/homepage/whitelist_test.go

實現思路

按照har文件的JSON結構定義對應的結構體，然后解析數據，生成請求數據，生成斷言數據，初始化測試套suite，格式化代碼，初始化包引用信息。

解析Har數據

定義結構體
Log struct {
		version string
		creator string
		Entries []struct {
			startedDateTime string
			time            string
			Request         struct {
				...
解析到json
func UnpackHar(har []byte) (logs *Har) {
	err := json.Unmarshal(har, &logs)
	if err != nil {
		fmt.Println(err)
	}
	return
}

轉換請求數據

轉換請求
轉換請求參數

GET

// 格式化請求參數為標准請求string
getReqParam := make(map[string]interface{}, 1)
if len(v.Request.QueryString) > 0 {
    for _, query := range v.Request.QueryString {
        getReqParam[query.Name] = query.Value
    }
}
// 獲取postReq數據
postReqParamStr := v.Request.PostData.Text

if v.Request.Method == "GET" {
    paramstr = genGetParam(InterfaceName, getReqParam)
}

func genGetParam(interfaceName string, param map[string]interface{}) (formatParam string) {

	// 對於請求參數的value值為 數組
	if len(param) > 0 {
		for k, v := range param {
			switch vv := v.(type) {
			case []interface{}:
				fmt.Sprintf(k, "is an array:", vv)
				temp, _ := json.Marshal(param)
				formatParam = fmt.Sprintf("%sParam = `%s`", interfaceName, fmt.Sprintf("%v", string(temp)))
				return
			default:
				// fmt.Println(k, "is of a type didn't handle")
			}
		}
	}
	temp, _ := json.Marshal(param)
	formatParam = fmt.Sprintf(`%sParam = map[string]interface{} %s`, interfaceName, fmt.Sprintf("%v", string(temp)))
	return
}

POST

postReqParamStr := v.Request.PostData.Text
    if v.Request.Method == "POST" {
    paramstr = genPostParam(InterfaceName, postReqParamStr)
}
func genPostParam(interfaceName string, postReqParamStr string) (formatParam string) {
	// formatParam = fmt.Sprintf(`%sParam = map[string]interface{} %s`, interfaceName, param)
	// fmt.Sprintf("%v", string(temp))
	postReqParam := make(map[string]interface{}, 1)

	if len(postReqParamStr) > 0 {
		// 判斷第一個字符是否為{}, 做傳遞數據為數組[]的兼容
		if []rune(postReqParamStr)[0] == '{' {
			var x interface{}
			err := json.Unmarshal([]byte(postReqParamStr), &x)
			if err != nil {
				fmt.Println("err", err)
			}

			postReqParam = x.(map[string]interface{})
			// fmt.Println(postReqParam)
			// 判斷value中是否存在數組
			for k, v := range postReqParam {
				switch vv := v.(type) {
				// switch vv := v.(type) {
				case []interface{}:
					fmt.Sprintf(k, "is an array:", vv)
					// param[k] = fmt.Sprintf("`%s`", vv)
					temp, _ := json.Marshal(postReqParam)
					formatParam = fmt.Sprintf("%sParam = `%s`", interfaceName, fmt.Sprintf("%v", string(temp)))
					paramType = "string"
					return
				default:
					formatParam = genGetParam(interfaceName, postReqParam)
					// fmt.Println(k, "is of a type didn't handle")
				}
			}
			// 如果為數組，做如下處理
		} else {
			var y []interface{}
			err := json.Unmarshal([]byte(postReqParamStr), &y)
			if err != nil {
				fmt.Println("err", err)
			}

			postReqParam = y[0].(map[string]interface{})
			temp, _ := json.Marshal(postReqParam)

			// 聲明請求類型
			paramType = "[]map[string]interface{}"
			formatParam = fmt.Sprintf(`%sParam =[]map[string]interface{}{%s}`, interfaceName, string(temp))
			// 無法使用 判斷類型 Param := utils.MapDeepCopy(Hebinz123.XlppcPlaylistApiV1RemarkDelParam)
		}
	}
	// temp, _ := json.Marshal(param)
	// formatParam = fmt.Sprintf(`%sParam = map[string]interface{} %s`, interfaceName, fmt.Sprintf("%v", string(temp)))
	return
}

寫業務請求數據

寫gotest測試用例數據

格式化請求參數為標准請求string。

初始化寫入suit文件

這里有一個注意點，Test后緊接的數據必須是大寫。

格式化測試文件

使用goimports庫初始化導入數據包。

install生成的業務請求目錄

使用go install目錄生成導入業務請求目錄

格式化響應斷言

使用類型判斷格式化接口返回數據為標准斷言string。

可能遇到的問題

  • 初始化讀取文件的存儲buf的size和其實際大小不一致時，json 解析出錯“invalid character '\x00' after top-level value”
  • go install 執行失敗，導致測試用例無法找到其依賴包
  • get請求，post請求參數在har文件中的存儲方式不一致，獲取數據的方式差別很大
  • 域名及接口命名規則不一致，-、.等等風格不一致
  • 測試suite 緊接Test后方的字符需為大寫的字母，否則服務無法被發現，所以需要做大小寫轉換

完整代碼

詳細代碼如下，注釋已經給得比較清晰：

package main

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
)

var (
	baseDomain         = "test.bbs.com"    // 測試域名，用於切割出請求路徑
	bizBaseFolder      = "business/CN_bbs" //業務請求目錄
	testCaseBaseFolder = "testcase/CN_bbs" // 測試用例目錄
	serverName         = "cinecismGo"      // 服務名
	paramType          = ""
)

func main() {
	userFile := "20190917-cinecismgo.har" // 抓包文件地址
	fl, err := os.Open(userFile)
	if err != nil {
		fmt.Println(userFile, err)
		return
	}
	defer fl.Close()

	// 讀取har數據
	fileInfo, err := fl.Stat()
	buf := make([]byte, fileInfo.Size()) // “invalid character '\x00' after top-level value”
	fl.Read(buf)
	data := UnpackHar(buf)

	for _, v := range data.Log.Entries {
		// 每一個循環初始化請求參數類型
		paramType = "map[string]interface{}"
		paramstr := ""

		// 初始化 請求path，生成標准請求接口名稱
		pathStr, path := initPath(v.Request.URL)
		InterfaceName := formatInterfaceName(pathStr)

		// 格式化請求參數為標准請求string
		getReqParam := make(map[string]interface{}, 1)
		if len(v.Request.QueryString) > 0 {
			for _, query := range v.Request.QueryString {
				getReqParam[query.Name] = query.Value
			}
		}
		// 獲取postReq數據
		postReqParamStr := v.Request.PostData.Text

		if v.Request.Method == "GET" {
			paramstr = genGetParam(InterfaceName, getReqParam)
		}
		if v.Request.Method == "POST" {
			paramstr = genPostParam(InterfaceName, postReqParamStr)
		}

		// 格式化接口返回數據為標准斷言string
		text, _ := base64.StdEncoding.DecodeString(v.Response.Content.Text)
		responseAssertStr := initAssert(text)

		// 創建業務請求文件、測試用例文件
		run(serverName, path, InterfaceName, v.Request.Method, responseAssertStr, paramstr)

		// 【待補充】handle Headers數據
		// fmt.Println(initHeaders(data))
	}
}

func initAssert(text []byte) (responseAssertStr string) {
	if len(text) > 0 {
		var Response interface{}
		err := json.Unmarshal(text, &Response)
		if err != nil {
			fmt.Println("err", err)
		}

		responseMap := Response.(map[string]interface{})
		res := []string{}
		for k, v := range responseMap {
			switch vv := v.(type) {
			case string:
				// fmt.Println(k, "is string", vv)
				res = append(res, fmt.Sprintf("%s, _ := js.Get(\"%s\").String() \n assert.Equal(%s, `%v`)", k, k, k, string(vv)))
			case int64:
				// fmt.Println(k, "is int", vv)
				res = append(res, fmt.Sprintf("%s, _ := js.Get(\"%s\").Int() \n assert.Equal(%s, %v)", k, k, k, string(vv)))
			case float64:
				// fmt.Println(k, "is float64", vv)
				res = append(res, fmt.Sprintf("%s, _ := js.Get(\"%s\").Int() \n assert.Equal(%s, %v)", k, k, k, vv))
			case bool:
				// fmt.Println(k, "is bool", vv)
				res = append(res, fmt.Sprintf("%s, _ := js.Get(\"%s\").Bool() \n assert.Equal(%s, %v)", k, k, k, vv))
			case []interface{}:
				// fmt.Println(k, "is an array:", vv)
				res = append(res, fmt.Sprintf("// Key【%s】的子層級的value值未生成斷言，系多層級數組數據，具體值如下：", k))
				res = append(res, fmt.Sprintf("// %v ", vv))
			case map[string]interface{}:
				// fmt.Println(k, "is an map:", vv)
				temp, _ := json.Marshal(vv)
				res = append(res, fmt.Sprintf("// Key【%s】的子層級value值未生成斷言，系多層級Map數據，具體值如下：", k))
				res = append(res, fmt.Sprintf("// %v ", string(temp)))
			default:
				// fmt.Println(k, "is of a type didn't handle", vv)
			}
			responseAssertStr = strings.Join(res, "\n")
		}
	}
	return
}

func initPath(URL string) (pathStr, path string) {
	pathStr = strings.Split(URL, baseDomain)[1]
	if strings.Contains(pathStr, "?") {
		pathStr = strings.Split(pathStr, "?")[0]
		path = strings.Split(pathStr, "?")[0]
	} else {
		path = pathStr
	}
	if strings.Contains(pathStr, ".") {
		pathStr = strings.Replace(pathStr, ".", "/", 10)
		pathStr = strings.Replace(pathStr, "-", "/", 10)
	}
	// fmt.Println(path)
	// fmt.Println("pathStr", pathStr)
	return
}

func run(serverName, path, InterfaceName, method, responseAssertStr string, Param string) {
	// 初始化測試文件
	InterfaceFilepath := filepath.Join(bizBaseFolder, serverName)
	Testcasefilepath := filepath.Join(testCaseBaseFolder, serverName)
	InterfaceFileame := InterfaceName + ".go"
	Testcasefilename := InterfaceName + "_test.go"

	// 創建並寫入標准請求信息
	file, err := createFile(InterfaceFilepath, InterfaceFileame)
	if err != nil {
		fmt.Println("createInterfaceFile", err)
	}
	writeParam(file, serverName, []string{Param})
	writeReq(file, InterfaceName, path, method)
	defer file.Close()

	// 創建並寫入測試用例信息
	file1, err := createFile(Testcasefilepath, Testcasefilename)
	if err != nil {
		fmt.Println("createTestcasefile", err)
	}

	// 寫入suit文件
	initTestsuit(serverName)

	// 寫入測試用例
	writeTestcase(file1, serverName, InterfaceName, responseAssertStr)
	defer file1.Close()

	// 格式化測試文件
	exec.Command("goimports", "-w", InterfaceFilepath).Run()
	exec.Command("goimports", "-w", Testcasefilepath).Run()

	// 導入InterfaceFilepath
	exec.Command("go", "install", InterfaceFilepath).Run()
}

func initHeaders(har *Har) map[string]string {
	var headers = make(map[string]string)
	// fmt.Println(len(har.Log.Entries[0].Request.Headers))

	for _, v := range har.Log.Entries[0].Request.Headers {
		headers[v.Name] = v.Value
	}
	return headers
}

func createFile(filepaths, filename string) (file *os.File, err error) {
	os.MkdirAll(filepaths, 0777)
	file, err = os.Create(filepath.Join(filepaths, filename))
	return
}

func createInterfaceFile(path, filename string) (file *os.File, err error) {
	filename = filename + ".go"
	filepath := bizBaseFolder + "/" + path + "/"
	os.MkdirAll(filepath, 0777)
	file, err = os.Create(filepath + filename)
	return
}

func createTestcasefile(path, filename string) (file *os.File, err error) {
	filename = filename + "_test.go"
	filepath := testCaseBaseFolder + "/" + path + "/"
	os.MkdirAll(filepath, 0777)
	file, err = os.Create(filepath + filename)
	return
}

func initTestsuit(serverName string) {
	filename := serverName + "_suite_test.go"
	filepath := testCaseBaseFolder + "/" + serverName + "/"
	os.MkdirAll(filepath, 0777)
	file, err := os.Create(filepath + filename)
	if err != nil {
		fmt.Println("initTestsuit Error", err)
	}
	// Testsuite后的 首字母需大寫，否則suite無法正常檢索到testcase
	file.WriteString(fmt.Sprintf(
		`package %s_test

		import (
			"testing"

			. "github.com/onsi/ginkgo"
			. "github.com/onsi/gomega"
		)

		func Test%s(t *testing.T) {
			RegisterFailHandler(Fail)
			RunSpecs(t, "%s Suite")
		}`, serverName, Capitalize(serverName), serverName))
}

func writeTestcase(file *os.File, serverName, InterfaceName, responseAssertStr string) {
	// 接口引入路徑 【服務名稱.接口名稱】
	interfaceImportPath := serverName + "." + InterfaceName
	// 接口標准請求參數 【接口名稱Param】
	paramImportPath := interfaceImportPath + "Param"

	// 接口標准請求參數拷貝，請求參數為非標准【map[string]interface{}】類型時，該參數為空
	tempParamStr := ""
	// 是否使用mapDeepCopy，請求參數為非標准【map[string]interface{}】類型時 使用
	mapDeepCopy := ""
	if paramType != "map[string]interface{}" {
		tempParamStr = paramImportPath
	}

	if paramType == "map[string]interface{}" {
		tempParamStr = "Param"
		mapDeepCopy = fmt.Sprintf(`Param := utils.MapDeepCopy(%s)`, paramImportPath)
	}

	// fmt.Println("---------------->", paramType)
	file.WriteString(fmt.Sprintf("package %s_test\n\n", serverName))
	file.WriteString(`import . "github.com/onsi/ginkgo"`)
	file.WriteString("\n\n")
	file.WriteString(fmt.Sprintf(`var _ = Describe("%s", func() {
		headers := common.EntireHeaderParam
		assert := assert.New(GinkgoT())
		BeforeEach(func() {
			By("begin test")
		})
		JustBeforeEach(func() {
			By("just say start")
		})
		AfterEach(func() {
			By("end test")
		})
		Context("%s", func() {
			It("正常%s", func() {
				%s
				ret, resp, _ := %s(%s, headers)
				assert.Equal(ret.StatusCode, 200)
				js, errs := simplejson.NewJson(resp)
				if errs != nil {
					panic(errs)
				}
				%s
			})
		})
	})`, serverName, InterfaceName, InterfaceName, mapDeepCopy, interfaceImportPath, tempParamStr, responseAssertStr))
}

func writeParam(file *os.File, serverName string, params []string) {
	file.WriteString(fmt.Sprintf("package %s", serverName))
	file.WriteString("\n\n\n")
	file.WriteString("var (")
	for _, param := range params {
		file.WriteString(param)
	}
	file.WriteString(")")
	file.WriteString("\n\n\n")
}

func writeReq(file *os.File, InterfaceName, path, method string) {
	file.WriteString(fmt.Sprintf(`func %s(param %s, header map[string]string) (ret gorequest.Response, content []byte, result string) {
		path := "%s"
		url := CN_bbs.TESTSERVERDOMAIN + path
		ret, content = common.Common%s(url, param, header)
		fmt.Println(ret.Request.URL)
		// js, _ := simplejson.NewJson([]byte(content))
		//result, _ = js.Get("result").String()
		return
	}`, InterfaceName, paramType, path, method))
}

func genGetParam(interfaceName string, param map[string]interface{}) (formatParam string) {

	// 對於請求參數的value值為 數組
	if len(param) > 0 {
		for k, v := range param {
			switch vv := v.(type) {
			case []interface{}:
				fmt.Sprintf(k, "is an array:", vv)
				temp, _ := json.Marshal(param)
				// 如果是數組格式，直接當作字符串處理（map[]interface{}格式無法表示該類型參數）
				formatParam = fmt.Sprintf("%sParam = `%s`", interfaceName, fmt.Sprintf("%v", string(temp)))
				return
			default:
				// fmt.Println(k, "is of a type didn't handle")
			}
		}
	}
	temp, _ := json.Marshal(param)
	formatParam = fmt.Sprintf(`%sParam = map[string]interface{} %s`, interfaceName, fmt.Sprintf("%v", string(temp)))
	return
}

func genPostParam(interfaceName string, postReqParamStr string) (formatParam string) {
	// formatParam = fmt.Sprintf(`%sParam = map[string]interface{} %s`, interfaceName, param)
	// fmt.Sprintf("%v", string(temp))
	postReqParam := make(map[string]interface{}, 1)

	if len(postReqParamStr) > 0 {
		// 判斷第一個字符是否為{}, 做傳遞數據為數組[]的兼容
		if []rune(postReqParamStr)[0] == '{' {
			var x interface{}
			err := json.Unmarshal([]byte(postReqParamStr), &x)
			if err != nil {
				fmt.Println("err", err)
			}

			postReqParam = x.(map[string]interface{})
			// fmt.Println(postReqParam)
			// 判斷value中是否存在數組
			for k, v := range postReqParam {
				switch vv := v.(type) {
				// switch vv := v.(type) {
				case []interface{}:
					fmt.Sprintf(k, "is an array:", vv)
					// param[k] = fmt.Sprintf("`%s`", vv)
					temp, _ := json.Marshal(postReqParam)
					formatParam = fmt.Sprintf("%sParam = `%s`", interfaceName, fmt.Sprintf("%v", string(temp)))
					paramType = "string"
					return
				default:
					formatParam = genGetParam(interfaceName, postReqParam)
					// fmt.Println(k, "is of a type didn't handle")
				}
			}
			// 如果為數組，做如下處理
		} else {
			var y []interface{}
			err := json.Unmarshal([]byte(postReqParamStr), &y)
			if err != nil {
				fmt.Println("err", err)
			}

			postReqParam = y[0].(map[string]interface{})
			temp, _ := json.Marshal(postReqParam)

			// 聲明請求類型
			paramType = "[]map[string]interface{}"
			formatParam = fmt.Sprintf(`%sParam =[]map[string]interface{}{%s}`, interfaceName, string(temp))
			// 無法使用 判斷類型 Param := utils.MapDeepCopy(Hebinz123.CNppcPlaylistApiV1RemarkDelParam)
		}
	}
	// temp, _ := json.Marshal(param)
	// formatParam = fmt.Sprintf(`%sParam = map[string]interface{} %s`, interfaceName, fmt.Sprintf("%v", string(temp)))
	return
}

func formatInterfaceName(path string) (InterfaceName string) {
	paths := strings.Split(path, "/")

	for k, v := range paths {
		paths[k] = Capitalize(v)
	}

	InterfaceName = strings.Join(paths, "")
	return
}

// Capitalize 字符首字母大寫
func Capitalize(str string) string {
	var upperStr string
	vv := []rune(str)
	for i := 0; i < len(vv); i++ {
		if i == 0 {
			if vv[i] >= 97 && vv[i] <= 122 { // 判斷是否是小寫字母
				vv[i] -= 32 // string的碼表相差32位
				upperStr += string(vv[i])
			} else {
				fmt.Println("Not begins with lowercase letter,")
				return str
			}
		} else {
			upperStr += string(vv[i])
		}
	}
	return upperStr
}

// Har Logs 解析
type Har struct {
	Log struct {
		version string
		creator string
		Entries []struct {
			startedDateTime string
			time            string
			Request         struct {
				Method      string
				URL         string
				httpVersion string
				Cookies     []string
				Headers     []struct {
					Name  string
					Value string
				}
				QueryString []struct {
					Name  string
					Value string
				}
				PostData struct {
					MimeType string
					Text     string
				}
				headersSize int32
				bodySize    int32
			}
			Response struct {
				_charlesStatus string
				Status         int32
				StatusText     string
				httpVersion    string
				cookies        []string
				Headers        []struct {
					Name  string
					Value string
				}
				Content struct {
					size     int32
					mimeType string
					Text     string
					Encoding string
				}
				redirectURL string
				headersSize int
				bodySize    int
			}
			serverIPAddress string
			cache           map[string]string
			timings         map[string]int32
		}
	}
}

// UnpackHar 解析 har
func UnpackHar(har []byte) (logs *Har) {
	err := json.Unmarshal(har, &logs)
	if err != nil {
		fmt.Println(err)
	}
	return
}


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 python+requests+yaml實現接口自動化用例 自動化用例設計 playwright+pytest+BDD+pom書寫自動化用例 jenkins執行自動化用例（詳細、有用、mark 優先級高高高） python3+Robot Framework+PyCharm第一個WEB UI自動化用例 接口自動化測試框架開發(pytest+allure+aiohttp+ 用例自動生成) 接口自動化：六.pytest寫用例 流量錄制回放助力接口自動化測試 根據接口文檔中的入參，生成自動化測試用例中的異常測試用例，包含用例描述，用例數據 【python接口自動化】- 正則用例參數化
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM