From 86b50e6d0d6dd8ccc589bc07281c5c934684165b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BE=90=E8=81=AA?= Date: Wed, 29 Dec 2021 15:23:36 +0800 Subject: [PATCH] add interface request verification method. --- convert.go | 37 +------------- internal/builtin/assertion.go | 8 ++-- internal/builtin/assertion_test.go | 77 ++++++++++++++++++++++++++++++ internal/builtin/function.go | 40 ++++++++++++++-- validate.go | 44 +++++++++++++++++ 5 files changed, 164 insertions(+), 42 deletions(-) diff --git a/convert.go b/convert.go index 3d9880eb..7cdedfae 100644 --- a/convert.go +++ b/convert.go @@ -2,15 +2,12 @@ package hrp import ( "bytes" - "encoding/csv" "encoding/json" "fmt" - "io/ioutil" - "path/filepath" - "strings" - "github.com/rs/zerolog/log" "gopkg.in/yaml.v3" + "io/ioutil" + "path/filepath" ) func (tc *TCase) Dump2JSON(path string) error { @@ -96,36 +93,6 @@ func loadFromYAML(path string) (*TCase, error) { return tc, err } -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") - 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") - 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") - panic(err) - } - var result []map[string]string - for i := 1; i < len(content); i++ { - row := make(map[string]string) - for j := 0; j < len(content[i]); j++ { - row[content[0][j]] = content[i][j] - } - result = append(result, row) - } - return result -} - func (tc *TCase) ToTestCase() (*TestCase, error) { testCase := &TestCase{ Config: &Config{cfg: tc.Config}, diff --git a/internal/builtin/assertion.go b/internal/builtin/assertion.go index a6395566..c995e26e 100644 --- a/internal/builtin/assertion.go +++ b/internal/builtin/assertion.go @@ -71,7 +71,7 @@ func GreaterThanLength(t assert.TestingT, expected, actual interface{}, msgAndAr if !ok { return assert.Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", actual), msgAndArgs...) } - if l > length { + if l <= length { return assert.Fail(t, fmt.Sprintf("\"%s\" should be more than %d item(s), but has %d", actual, length, l), msgAndArgs...) } return true @@ -86,7 +86,7 @@ func GreaterOrEqualsLength(t assert.TestingT, expected, actual interface{}, msgA if !ok { return assert.Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", actual), msgAndArgs...) } - if l >= length { + if l < length { return assert.Fail(t, fmt.Sprintf("\"%s\" should be no less than %d item(s), but has %d", actual, length, l), msgAndArgs...) } return true @@ -101,7 +101,7 @@ func LessThanLength(t assert.TestingT, expected, actual interface{}, msgAndArgs if !ok { return assert.Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", actual), msgAndArgs...) } - if l < length { + if l >= length { return assert.Fail(t, fmt.Sprintf("\"%s\" should be less than %d item(s), but has %d", actual, length, l), msgAndArgs...) } return true @@ -116,7 +116,7 @@ func LessOrEqualsLength(t assert.TestingT, expected, actual interface{}, msgAndA if !ok { return assert.Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", actual), msgAndArgs...) } - if l <= length { + if l > length { return assert.Fail(t, fmt.Sprintf("\"%s\" should be no more than %d item(s), but has %d", actual, length, l), msgAndArgs...) } return true diff --git a/internal/builtin/assertion_test.go b/internal/builtin/assertion_test.go index 632dad30..52d8d5d0 100644 --- a/internal/builtin/assertion_test.go +++ b/internal/builtin/assertion_test.go @@ -61,3 +61,80 @@ func TestEqualLength(t *testing.T) { } } } + +func TestLessThanLength(t *testing.T) { + testData := []struct { + raw interface{} + expected int + }{ + {"", 1}, + {[]string{}, 1}, + {map[string]interface{}{}, 1}, + {"a", 2}, + {[]string{"a"}, 2}, + {map[string]interface{}{"a": 123}, 2}, + } + + for _, data := range testData { + if !assert.True(t, LessThanLength(t, data.expected, data.raw)) { + t.Fail() + } + } +} + +func TestLessOrEqualsLength(t *testing.T) { + testData := []struct { + raw interface{} + expected int + }{ + {"", 1}, + {[]string{}, 1}, + {map[string]interface{}{"A": 111}, 1}, + {"a", 1}, + {[]string{"a"}, 2}, + {map[string]interface{}{"a": 123}, 2}, + } + + for _, data := range testData { + if !assert.True(t, LessOrEqualsLength(t, data.expected, data.raw)) { + t.Fail() + } + } +} + +func TestGreaterThanLength(t *testing.T) { + testData := []struct { + raw interface{} + expected int + }{ + {"abcd", 3}, + {[]string{"a", "b", "c"}, 2}, + {map[string]interface{}{"a": 123, "b": 223, "c": 323}, 2}, + } + + for _, data := range testData { + if !assert.True(t, GreaterThanLength(t, data.expected, data.raw)) { + t.Fail() + } + } +} + +func TestGreaterOrEqualsLength(t *testing.T) { + testData := []struct { + raw interface{} + expected int + }{ + {"abcd", 3}, + {[]string{"w"}, 1}, + {map[string]interface{}{"A": 111}, 1}, + {"a", 1}, + {[]string{"a", "b", "c"}, 2}, + {map[string]interface{}{"a": 123, "b": 223, "c": 323}, 2}, + } + + for _, data := range testData { + if !assert.True(t, GreaterOrEqualsLength(t, data.expected, data.raw)) { + t.Fail() + } + } +} diff --git a/internal/builtin/function.go b/internal/builtin/function.go index be7c129e..3d5c96de 100644 --- a/internal/builtin/function.go +++ b/internal/builtin/function.go @@ -2,10 +2,14 @@ package builtin import ( "crypto/md5" + "encoding/csv" "encoding/hex" - "github.com/httprunner/hrp" + "github.com/rs/zerolog/log" + "io/ioutil" "math" "math/rand" + "path/filepath" + "strings" "time" ) @@ -15,8 +19,8 @@ var Functions = map[string]interface{}{ "gen_random_string": genRandomString, // call with one argument "max": math.Max, // call with two arguments "md5": MD5, - "parameterize": hrp.LoadFromCSV, - "P": hrp.LoadFromCSV, + "parameterize": LoadFromCSV, + "P": LoadFromCSV, } func init() { @@ -47,3 +51,33 @@ func MD5(str string) string { hasher.Write([]byte(str)) return hex.EncodeToString(hasher.Sum(nil)) } + +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") + 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") + 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") + panic(err) + } + var result []map[string]string + for i := 1; i < len(content); i++ { + row := make(map[string]string) + for j := 0; j < len(content[i]); j++ { + row[content[0][j]] = content[i][j] + } + result = append(result, row) + } + return result +} diff --git a/validate.go b/validate.go index f5d67a8a..f8113779 100644 --- a/validate.go +++ b/validate.go @@ -67,3 +67,47 @@ func (s *StepRequestValidation) AssertLengthEqual(jmesPath string, expected inte s.step.Validators = append(s.step.Validators, v) return s } + +func (s *StepRequestValidation) AssertLengthLessThan(jmesPath string, expected interface{}, msg string) *StepRequestValidation { + v := Validator{ + Check: jmesPath, + Assert: "length_less_than", + Expect: expected, + Message: msg, + } + s.step.Validators = append(s.step.Validators, v) + return s +} + +func (s *StepRequestValidation) AssertLengthLessOrEquals(jmesPath string, expected interface{}, msg string) *StepRequestValidation { + v := Validator{ + Check: jmesPath, + Assert: "length_less_or_equals", + Expect: expected, + Message: msg, + } + s.step.Validators = append(s.step.Validators, v) + return s +} + +func (s *StepRequestValidation) AssertLengthGreaterThan(jmesPath string, expected interface{}, msg string) *StepRequestValidation { + v := Validator{ + Check: jmesPath, + Assert: "length_greater_than", + Expect: expected, + Message: msg, + } + s.step.Validators = append(s.step.Validators, v) + return s +} + +func (s *StepRequestValidation) AssertLengthGreaterOrEquals(jmesPath string, expected interface{}, msg string) *StepRequestValidation { + v := Validator{ + Check: jmesPath, + Assert: "length_greater_or_equals", + Expect: expected, + Message: msg, + } + s.step.Validators = append(s.step.Validators, v) + return s +}