From 43deb78b26b42f94ec5cc37f2a72349ac15ed464 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BE=90=E8=81=AA?= Date: Tue, 28 Dec 2021 18:16:02 +0800 Subject: [PATCH] feat: data-driven. --- boomer.go | 3 + convert.go | 6 +- examples/account.csv | 4 + examples/demo.yaml | 7 -- examples/parameters_test.json | 57 ++++++++++++++ examples/parameters_test.yaml | 38 +++++++++ internal/builtin/function.go | 5 ++ parser.go | 141 ++++++++++++++++++++++++---------- parser_test.go | 53 +++++++++++++ runner.go | 3 + utils.go | 41 ---------- 11 files changed, 268 insertions(+), 90 deletions(-) create mode 100644 examples/account.csv create mode 100644 examples/parameters_test.json create mode 100644 examples/parameters_test.yaml delete mode 100644 utils.go diff --git a/boomer.go b/boomer.go index c70bb005..62b8933e 100644 --- a/boomer.go +++ b/boomer.go @@ -47,6 +47,9 @@ func (b *hrpBoomer) Run(testcases ...ITestCase) { } cfg := testcase.Config.ToStruct() parameters := getParameters(testcase.Config) + if parameters == nil { + parameters = []map[string]interface{}{{}} + } for _, parameter := range parameters { cfg.Variables = mergeVariables(parameter, cfg.Variables) task := b.convertBoomerTask(testcase) diff --git a/convert.go b/convert.go index f7579334..ba3b8d15 100644 --- a/convert.go +++ b/convert.go @@ -100,20 +100,20 @@ func loadFromCSV(path string) []map[string]string { path, err := filepath.Abs(path) if err != nil { log.Error().Str("path", path).Err(err).Msg("convert absolute path failed") - return nil + panic(err) } log.Info().Str("path", path).Msg("load csv file") file, err := ioutil.ReadFile(path) if err != nil { log.Error().Err(err).Msg("load csv file failed") - return nil + panic(err) } r := csv.NewReader(strings.NewReader(string(file))) content, err := r.ReadAll() if err != nil { log.Error().Err(err).Msg("parse csv file failed") - return nil + panic(err) } var result []map[string]string for i := 1; i < len(content); i++ { diff --git a/examples/account.csv b/examples/account.csv new file mode 100644 index 00000000..67ce22c6 --- /dev/null +++ b/examples/account.csv @@ -0,0 +1,4 @@ +username,password +test1,111111 +test2,222222 +test3,333333 \ No newline at end of file diff --git a/examples/demo.yaml b/examples/demo.yaml index e0f70360..a0cee432 100644 --- a/examples/demo.yaml +++ b/examples/demo.yaml @@ -7,11 +7,6 @@ config: "n": 5 varFoo1: ${gen_random_string($n)} varFoo2: ${max($a, $b)} - parameters: - username-password: ${parameterize(examples/account.csv)} - user_agent: ["iOS/10.1", "iOS/10.2"] - parameters_setting: - strategy: random teststeps: - name: transaction 1 start transaction: @@ -24,8 +19,6 @@ teststeps: params: foo1: $varFoo1 foo2: $varFoo2 - foo3: $username - foo4: $password headers: User-Agent: HttpRunnerPlus variables: diff --git a/examples/parameters_test.json b/examples/parameters_test.json new file mode 100644 index 00000000..6ad52032 --- /dev/null +++ b/examples/parameters_test.json @@ -0,0 +1,57 @@ +{ + "config": { + "name": "request methods testcase: validate with parameters", + "parameters": { + "user_agent": [ + "iOS/10.1", + "iOS/10.2" + ], + "username-password": "${parameterize(examples/account.csv)}", + "app_version": "${getAppVersion()}" + }, + "parameters_setting": { + "strategy": "random" + }, + "variables": { + "app_version": "f1" + }, + "base_url": "https://postman-echo.com", + "verify": false + }, + "teststeps": [ + { + "name": "get with params", + "variables": { + "foo1": "$username", + "foo2": "$password", + "foo3": "$app_version" + }, + "request": { + "method": "GET", + "url": "/get", + "params": { + "foo1": "$foo1", + "foo2": "$foo2", + "foo3": "$foo3" + }, + "headers": { + "User-Agent": "$user_agent,$app_version" + } + }, + "validate": [ + { + "check": "status_code", + "assert": "equals", + "expect": 200, + "msg": "check status code" + }, + { + "check": "body.args.foo3", + "assert": "not_equal", + "expect": "f1", + "msg": "check app version" + } + ] + } + ] +} \ No newline at end of file diff --git a/examples/parameters_test.yaml b/examples/parameters_test.yaml new file mode 100644 index 00000000..7afb4252 --- /dev/null +++ b/examples/parameters_test.yaml @@ -0,0 +1,38 @@ +config: + name: "request methods testcase: validate with parameters" + parameters: + user_agent: ["iOS/10.1", "iOS/10.2"] + username-password: ${parameterize(examples/account.csv)} + app_version: ${getAppVersion()} + parameters_setting: + strategy: random + variables: + app_version: f1 + base_url: "https://postman-echo.com" + verify: False + +teststeps: +- + name: get with params + variables: + foo1: $username + foo2: $password + foo3: $app_version + request: + method: GET + url: /get + params: + foo1: $foo1 + foo2: $foo2 + foo3: $foo3 + headers: + User-Agent: $user_agent,$app_version + validate: + - check: status_code + assert: equals + expect: 200 + msg: check status code + - check: body.args.foo3 + assert: not_equal + expect: f1 + msg: check app version \ No newline at end of file diff --git a/internal/builtin/function.go b/internal/builtin/function.go index d1d3dd3b..2384d654 100644 --- a/internal/builtin/function.go +++ b/internal/builtin/function.go @@ -14,6 +14,7 @@ var Functions = map[string]interface{}{ "gen_random_string": genRandomString, // call with one argument "max": math.Max, // call with two arguments "md5": MD5, + "getAppVersion": getAppVersion, // test } func init() { @@ -44,3 +45,7 @@ func MD5(str string) string { hasher.Write([]byte(str)) return hex.EncodeToString(hasher.Sum(nil)) } + +func getAppVersion() []float64 { + return []float64{3.1, 3.3} +} diff --git a/parser.go b/parser.go index eed50964..e95946c8 100644 --- a/parser.go +++ b/parser.go @@ -3,13 +3,16 @@ package hrp import ( "encoding/json" "fmt" - "github.com/maja42/goval" - "github.com/pkg/errors" - "github.com/rs/zerolog/log" + "math/rand" "net/url" "reflect" "regexp" "strings" + "time" + + "github.com/maja42/goval" + "github.com/pkg/errors" + "github.com/rs/zerolog/log" "github.com/httprunner/hrp/internal/builtin" ) @@ -247,6 +250,15 @@ func mergeVariables(variables, overriddenVariables map[string]interface{}) map[s return mergedVariables } +func contains(s []string, e string) bool { + for _, a := range s { + if strings.EqualFold(a, e) { + return true + } + } + return false +} + func getMappingFunction(funcName string) (interface{}, error) { if function, ok := builtin.Functions[funcName]; ok { // function is builtin @@ -505,12 +517,43 @@ func findallVariables(raw string) variableSet { return varSet } +func shuffleCartesianProduct(slice []map[string]interface{}) { + if slice == nil || len(slice) == 0 { + return + } + r := rand.New(rand.NewSource(time.Now().Unix())) + for len(slice) > 0 { + n := len(slice) + randIndex := r.Intn(n) + slice[n-1], slice[randIndex] = slice[randIndex], slice[n-1] + slice = slice[:n-1] + } +} + +func genCartesianProduct(params [][]map[string]interface{}) []map[string]interface{} { + if params == nil || len(params) == 0 { + return nil + } + var cartesianProduct []map[string]interface{} + cartesianProduct = params[0] + for i := 0; i < len(params)-1; i++ { + var tempProduct []map[string]interface{} + for _, param1 := range cartesianProduct { + for _, param2 := range params[i+1] { + tempProduct = append(tempProduct, mergeVariables(param1, param2)) + } + } + cartesianProduct = tempProduct + } + return cartesianProduct +} + func getParameters(config IConfig) []map[string]interface{} { cfg := config.ToStruct() // parse config parameters parsedParams, err := parseParameters(cfg.Parameters, cfg.Variables) if err != nil { - log.Error().Interface("params", cfg.Parameters).Err(err).Msg("parse config parameters failed") + log.Error().Interface("parameters", cfg.Parameters).Err(err).Msg("parse config parameters failed") } if cfg.ParametersSetting["strategy"] != nil && strings.ToLower(cfg.ParametersSetting["strategy"].(string)) == "random" { shuffleCartesianProduct(parsedParams) @@ -519,10 +562,13 @@ func getParameters(config IConfig) []map[string]interface{} { } func parseParameters(parameters map[string]interface{}, variablesMapping map[string]interface{}) ([]map[string]interface{}, error) { - var parsedParametersList [][]map[string]interface{} + if parameters == nil || len(parameters) == 0 { + return nil, nil + } + var parsedParametersSlice [][]map[string]interface{} for k, v := range parameters { - parameterNameList := strings.Split(k, "-") - var parameterList []map[string]interface{} + parameterNameSlice := strings.Split(k, "-") + var parameterSlice []map[string]interface{} rawValue := reflect.ValueOf(v) switch rawValue.Kind() { case reflect.String: @@ -533,55 +579,72 @@ func parseParameters(parameters map[string]interface{}, variablesMapping map[str } parsedParameterRawValue := reflect.ValueOf(parsedParameterContent) if parsedParameterRawValue.Kind() != reflect.Slice { - log.Error().Interface("parameter", parameters).Msg("[parseParameters] parameter content should be List or Text(variables or functions call), got %v") - return nil, errors.New("parameter content should be List or Text(variables or functions call)") + log.Error().Interface("parameter", parameters).Msg("[parseParameters] parsed parameter content should be Slice, got %v") + return nil, errors.New("parsed parameter content should be Slice") } for i := 0; i < parsedParameterRawValue.Len(); i++ { parameterMap := make(map[string]interface{}) - if parsedParameterRawValue.Index(i).Kind() == reflect.Map { - for _, key := range parameterNameList { - parameterMap[key] = parsedParameterRawValue.Index(i).MapIndex(reflect.ValueOf(key)).Interface() + // e.g. + elem := reflect.ValueOf(parsedParameterRawValue.Index(i).Interface()) + if elem.Kind() == reflect.Map { + // e.g. [{"username": "test1", "password": "passwd1", "other": "111"}, {"username": "test2", "password": "passwd2", "other": ""222}] + // -> [{"username": "test1", "password": "passwd1"}, {"username": "test2", "password": "passwd2"}] (username, password in parameterNameSlice) + for _, key := range parameterNameSlice { + if _, ok := elem.Interface().(map[string]string)[key]; ok { + parameterMap[key] = elem.MapIndex(reflect.ValueOf(key)).Interface() + } else { + log.Error().Interface("parameterNameSlice", parameterNameSlice).Msg("[parseParameters] parameter name not found") + return nil, errors.New("parameter name not found") + } } - } else if parsedParameterRawValue.Index(i).Kind() == reflect.Slice { - if len(parameterNameList) != parsedParameterRawValue.Index(i).Len() { - log.Error().Interface("parameter", parameters).Msg("[parseParameters] parameter name list and parameter content list should have the same length") - return nil, errors.New("parameter name list and parameter content list should have the same length") + } else if elem.Kind() == reflect.Slice { + // e.g. [["test1", "passwd1"], ["test2", "passwd2"]] -> [{"username": "test1", "password": "passwd1"}, {"username": "test2", "password": "passwd2"}] + if len(parameterNameSlice) != elem.Len() { + log.Error().Interface("parameter", parameters).Msg("[parseParameters] parameter name Slice and parameter content Slice should have the same length") + return nil, errors.New("parameter name Slice and parameter cjntent Slice should have the same length") + } else { + for j := 0; j < elem.Len(); j++ { + parameterMap[parameterNameSlice[j]] = elem.Index(j).Interface() + } } - for i := 0; i < parsedParameterRawValue.Index(i).Len(); i++ { - parameterMap[parameterNameList[i]] = parsedParameterRawValue.Index(i).Index(i).Interface() - } - } else if len(parameterNameList) == 1 { - parameterMap[parameterNameList[0]] = parsedParameterRawValue.Index(i).Interface() } else { - log.Error().Interface("parameter", parameters).Msg("[parseParameters] parameter content should be List or Text(variables or functions call), got %v") - return nil, errors.New("parameter content should be List or Text(variables or functions call)") + // e.g. ${getAppVersion()} -> [3.1, 3.0] -> [{"app_version": 3.1}, {"app_version": 3.0}] + if len(parameterNameSlice) != 1 { + log.Error().Interface("parameterNameSlice", parameterNameSlice).Msg("[parseParameters] parameter name slice should have only one element when parameter content is string") + return nil, errors.New("parameter name slice should have only one element when parameter content is string") + } + parameterMap[parameterNameSlice[0]] = elem.Interface() } - parameterList = append(parameterList, parameterMap) + parameterSlice = append(parameterSlice, parameterMap) } case reflect.Slice: for i := 0; i < rawValue.Len(); i++ { parameterMap := make(map[string]interface{}) - if rawValue.Index(i).Kind() == reflect.Interface || rawValue.Index(i).Kind() == reflect.String { - parameterMap[parameterNameList[0]] = rawValue.Index(i).Interface() - } else if rawValue.Index(i).Kind() == reflect.Slice { - if len(parameterNameList) != rawValue.Index(i).Len() { - log.Error().Interface("parameter", parameters).Msg("[parseParameters] parameter name list and parameter content list should have the same length") - return nil, errors.New("parameter name list and parameter content list should have the same length") + elem := reflect.ValueOf(rawValue.Index(i).Interface()) + if elem.Kind() == reflect.Slice { + // e.g. username-password: [["test1", "passwd1"], ["test2", "passwd2"]] + if len(parameterNameSlice) != elem.Len() { + log.Error().Interface("parameter", parameters).Msg("[parseParameters] parameter name Slice and parameter content Slice should have the same length") + return nil, errors.New("parameter name Slice and parameter content Slice should have the same length") } - for i := 0; i < rawValue.Index(i).Len(); i++ { - parameterMap[parameterNameList[i]] = rawValue.Index(i).Index(i).Interface() + for j := 0; j < elem.Len(); j++ { + parameterMap[parameterNameSlice[j]] = elem.Index(j).Interface() } } else { - log.Error().Interface("parameter", parameters).Msg("[parseParameters] parameter content should be List or Text(variables or functions call), got %v") - return nil, errors.New("parameter content should be List or Text(variables or functions call)") + // e.g. user_agent: ["iOS/10.1", "iOS/10.2"] + if len(parameterNameSlice) != 1 { + log.Error().Interface("parameterNameSlice", parameterNameSlice).Msg("[parseParameters] parameter name slice should have only one element when parameter content is string") + return nil, errors.New("parameter name slice should have only one element when parameter content is string") + } + parameterMap[parameterNameSlice[0]] = elem.Interface() } - parameterList = append(parameterList, parameterMap) + parameterSlice = append(parameterSlice, parameterMap) } default: - log.Error().Interface("parameter", parameters).Msg("[parseParameters] parameter content should be List or Text(variables or functions call), got %v") - return nil, errors.New("parameter content should be List or Text(variables or functions call)") + log.Error().Interface("parameter", parameters).Msg("[parseParameters] parameter content should be Slice or Text(variables or functions call)") + return nil, errors.New("parameter content should be Slice or Text(variables or functions call)") } - parsedParametersList = append(parsedParametersList, parameterList) + parsedParametersSlice = append(parsedParametersSlice, parameterSlice) } - return genCartesianProduct(parsedParametersList), nil + return genCartesianProduct(parsedParametersSlice), nil } diff --git a/parser_test.go b/parser_test.go index 33f3ae76..194f70f1 100644 --- a/parser_test.go +++ b/parser_test.go @@ -618,3 +618,56 @@ func TestFindallVariables(t *testing.T) { } } } + +func TestParseParameters(t *testing.T) { + testData := []struct { + rawVars map[string]interface{} + expectVars []map[string]interface{} + }{ + { + map[string]interface{}{"username-password": "${parameterize(examples/account.csv)}", "user_agent": []interface{}{"IOS/10.1", "IOS/10.2"}}, + []map[string]interface{}{{"username": "test1", "password": "111111", "user_agent": "IOS/10.1"}, + {"username": "test1", "password": "111111", "user_agent": "IOS/10.2"}, + {"username": "test2", "password": "222222", "user_agent": "IOS/10.1"}, + {"username": "test2", "password": "222222", "user_agent": "IOS/10.2"}, + {"username": "test3", "password": "333333", "user_agent": "IOS/10.1"}, + {"username": "test3", "password": "333333", "user_agent": "IOS/10.2"}}, + }, + { + map[string]interface{}{}, + nil, + }, + { + nil, + nil, + }, + } + for _, data := range testData { + value, _ := parseParameters(data.rawVars, map[string]interface{}{}) + if !assert.Equal(t, data.expectVars, value) { + t.Fail() + } + } +} + +func TestParseParametersError(t *testing.T) { + testData := []struct { + rawVars map[string]interface{} + }{ + { + map[string]interface{}{"username_password": "${parameterize(examples/account.csv)}", "user_agent": []interface{}{"IOS/10.1", "IOS/10.2"}}, + }, + { + map[string]interface{}{"username-password": "${parameterize(examples/account.csv)}", "user-agent": []interface{}{"IOS/10.1", "IOS/10.2"}}, + }, + { + map[string]interface{}{"username-password": "${param(examples/account.csv)}", "user_agent": []interface{}{"IOS/10.1", "IOS/10.2"}}, + }, + } + for _, data := range testData { + _, err := parseParameters(data.rawVars, map[string]interface{}{}) + if !assert.Error(t, err) { + t.Fail() + } + } +} diff --git a/runner.go b/runner.go index 18dff670..fea5b69b 100644 --- a/runner.go +++ b/runner.go @@ -131,6 +131,9 @@ func (r *hrpRunner) runCase(testcase *TestCase) error { cfg := config.ToStruct() log.Info().Str("testcase", config.Name()).Msg("run testcase start") parameters := getParameters(config) + if parameters == nil { + parameters = []map[string]interface{}{{}} + } for _, parameter := range parameters { cfg.Variables = mergeVariables(parameter, cfg.Variables) r.startTime = time.Now() diff --git a/utils.go b/utils.go deleted file mode 100644 index 455e0ff7..00000000 --- a/utils.go +++ /dev/null @@ -1,41 +0,0 @@ -package hrp - -import ( - "math/rand" - "strings" - "time" -) - -func contains(s []string, e string) bool { - for _, a := range s { - if strings.EqualFold(a, e) { - return true - } - } - return false -} - -func shuffleCartesianProduct(slice []map[string]interface{}) { - r := rand.New(rand.NewSource(time.Now().Unix())) - for len(slice) > 0 { - n := len(slice) - randIndex := r.Intn(n) - slice[n-1], slice[randIndex] = slice[randIndex], slice[n-1] - slice = slice[:n-1] - } -} - -func genCartesianProduct(params [][]map[string]interface{}) []map[string]interface{} { - var cartesianProduct []map[string]interface{} - cartesianProduct = params[0] - for i := 0; i < len(params)-1; i++ { - var tempProduct []map[string]interface{} - for _, param1 := range cartesianProduct { - for _, param2 := range params[i+1] { - tempProduct = append(tempProduct, mergeVariables(param1, param2)) - } - } - cartesianProduct = tempProduct - } - return cartesianProduct -}