From 4d6b22ef0859c3a0ffe6505d5314ca124b21cded Mon Sep 17 00:00:00 2001 From: ruancongyong Date: Thu, 20 May 2021 09:49:09 +0800 Subject: [PATCH 1/3] Propoal: Convenient way to generate mock object format code and add unit test --- core/bean/mock.go | 139 +++++++++++++++++++++++++++++++++++++++++ core/bean/mock_test.go | 74 ++++++++++++++++++++++ 2 files changed, 213 insertions(+) create mode 100644 core/bean/mock.go create mode 100644 core/bean/mock_test.go diff --git a/core/bean/mock.go b/core/bean/mock.go new file mode 100644 index 00000000..5b627f01 --- /dev/null +++ b/core/bean/mock.go @@ -0,0 +1,139 @@ +package bean + +import ( + "fmt" + "reflect" + "strconv" + "strings" +) + +// the mock object must be pointer of struct +// the element in mock object can be slices, structures, basic data types, pointers and interface +func Mock(v interface{}) (err error) { + + pv := reflect.ValueOf(v) + //the input must be pointer of struct + if pv.Kind() != reflect.Ptr || pv.IsNil() { + err = fmt.Errorf("not a pointer of struct") + return + } + err = mock(pv) + return +} + +func mock(pv reflect.Value) (err error) { + pt := pv.Type() + for i := 0; i < pt.Elem().NumField(); i++ { + ptt := pt.Elem().Field(i) + pvv := pv.Elem().FieldByName(ptt.Name) + if !pvv.CanSet() || !pvv.CanAddr() { + continue + } + kt := ptt.Type.Kind() + tagValue := ptt.Tag.Get("mock") + switch kt { + case reflect.Map: + continue + case reflect.Interface: + if pvv.IsNil() { // when interface is nil,can not sure the type + continue + } + pvv.Set(reflect.New(pvv.Elem().Type().Elem())) + err = mock(pvv.Elem()) + case reflect.Ptr: + err = mockPtr(pvv, ptt.Type.Elem()) + case reflect.Struct: + err = mock(pvv.Addr()) + case reflect.Array, reflect.Slice: + err = mockSlice(tagValue, pvv) + case reflect.String: + pvv.SetString(tagValue) + case reflect.Bool: + err = mockBool(tagValue, pvv) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + value, e := strconv.ParseInt(tagValue, 10, 64) + if e != nil || pvv.OverflowInt(value) { + err = fmt.Errorf("the value:%s is invalid", tagValue) + } + pvv.SetInt(value) + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + value, e := strconv.ParseUint(tagValue, 10, 64) + if e != nil || pvv.OverflowUint(value) { + err = fmt.Errorf("the value:%s is invalid", tagValue) + } + pvv.SetUint(value) + case reflect.Float32, reflect.Float64: + value, e := strconv.ParseFloat(tagValue, pvv.Type().Bits()) + if e != nil || pvv.OverflowFloat(value) { + err = fmt.Errorf("the value:%s is invalid", tagValue) + } + pvv.SetFloat(value) + default: + } + if err != nil { + return + } + } + return +} + +// mock slice value +func mockSlice(tagValue string, pvv reflect.Value) (err error) { + sliceMetas := strings.Split(tagValue, ":") + if len(sliceMetas) != 2 || sliceMetas[0] != "length" { + return + } + length, e := strconv.Atoi(sliceMetas[1]) + if e != nil { + return e + } + + sliceType := reflect.SliceOf(pvv.Type().Elem()) //get slice type + itemType := sliceType.Elem() // get the type of item in slice + value := reflect.MakeSlice(sliceType, 0, length) + newSliceValue := make([]reflect.Value, 0, length) + for k := 0; k < length; k++ { + itemValue := reflect.New(itemType).Elem() + // if item in slice is struct or pointer,must set zero value + switch itemType.Kind() { + case reflect.Struct: + err = mock(itemValue.Addr()) + case reflect.Ptr: + if itemValue.IsNil() { + itemValue.Set(reflect.New(itemType.Elem())) + if e := mock(itemValue); e != nil { + return e + } + } + } + newSliceValue = append(newSliceValue, itemValue) + if err != nil { + return + } + } + value = reflect.Append(value, newSliceValue...) + pvv.Set(value) + return +} + +//mock bool value +func mockBool(tagValue string, pvv reflect.Value) (err error) { + switch tagValue { + case "true": + pvv.SetBool(true) + case "false": + pvv.SetBool(false) + default: + err = fmt.Errorf("the value:%s is invalid", tagValue) + } + return +} + +//mock pointer +func mockPtr(pvv reflect.Value, ptt reflect.Type) (err error) { + if pvv.IsNil() { + pvv.Set(reflect.New(ptt)) //must set nil value to zero value + } + err = mock(pvv) + return +} diff --git a/core/bean/mock_test.go b/core/bean/mock_test.go new file mode 100644 index 00000000..0fe81f43 --- /dev/null +++ b/core/bean/mock_test.go @@ -0,0 +1,74 @@ +package bean + +import ( + "fmt" + "testing" +) + +func TestMock(t *testing.T) { + type MockSubSubObject struct { + A int `mock:"20"` + } + type MockSubObjectAnoy struct { + Anoy int `mock:"20"` + } + type MockSubObject struct { + A bool `mock:"true"` + B MockSubSubObject + } + type MockObject struct { + A string `mock:"aaaaa"` + B int8 `mock:"10"` + C []*MockSubObject `mock:"length:2"` + D bool `mock:"true"` + E *MockSubObject + F []int `mock:"length:3"` + G InterfaceA + H InterfaceA + MockSubObjectAnoy + } + m := &MockObject{G: &ImplA{}} + err := Mock(m) + if err != nil { + t.Fatalf("mock failed: %v", err) + } + if m.A != "aaaaa" || m.B != 10 || m.C[1].B.A != 20 || + !m.E.A || m.E.B.A != 20 || !m.D || len(m.F) != 3 { + t.Fail() + } + _, ok := m.G.(*ImplA) + if !ok { + t.Fail() + } + _, ok = m.G.(*ImplB) + if ok { + t.Fail() + } + _, ok = m.H.(*ImplA) + if ok { + t.Fail() + } + if m.Anoy != 20 { + t.Fail() + } +} + +type InterfaceA interface { + Item() +} + +type ImplA struct { + A string `mock:"aaa"` +} + +func (i *ImplA) Item() { + fmt.Println("implA") +} + +type ImplB struct { + B string `mock:"bbb"` +} + +func (i *ImplB) Item() { + fmt.Println("implB") +} From 580d694b0ecc012239f35aa9af22bc8823842a1e Mon Sep 17 00:00:00 2001 From: ruancongyong Date: Mon, 24 May 2021 21:26:46 +0800 Subject: [PATCH 2/3] fix deepsource bug --- CHANGELOG.md | 1 + core/bean/mock.go | 17 ++++++++++------- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c45fece0..bb8dbcd7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,6 @@ # developing +- Add: Convenient way to generate mock object [4620](https://github.com/beego/beego/issues/4397) - Lint: use golangci-lint. [4619](https://github.com/beego/beego/pull/4619) - Chore: format code. [4615](https://github.com/beego/beego/pull/4615) - Env: non-empty GOBIN & GOPATH. [4613](https://github.com/beego/beego/pull/4613) diff --git a/core/bean/mock.go b/core/bean/mock.go index 5b627f01..707d875e 100644 --- a/core/bean/mock.go +++ b/core/bean/mock.go @@ -10,9 +10,8 @@ import ( // the mock object must be pointer of struct // the element in mock object can be slices, structures, basic data types, pointers and interface func Mock(v interface{}) (err error) { - pv := reflect.ValueOf(v) - //the input must be pointer of struct + // the input must be pointer of struct if pv.Kind() != reflect.Ptr || pv.IsNil() { err = fmt.Errorf("not a pointer of struct") return @@ -26,7 +25,7 @@ func mock(pv reflect.Value) (err error) { for i := 0; i < pt.Elem().NumField(); i++ { ptt := pt.Elem().Field(i) pvv := pv.Elem().FieldByName(ptt.Name) - if !pvv.CanSet() || !pvv.CanAddr() { + if !pvv.CanSet() { continue } kt := ptt.Type.Kind() @@ -79,8 +78,12 @@ func mock(pv reflect.Value) (err error) { // mock slice value func mockSlice(tagValue string, pvv reflect.Value) (err error) { + if len(tagValue) == 0 { + return + } sliceMetas := strings.Split(tagValue, ":") if len(sliceMetas) != 2 || sliceMetas[0] != "length" { + err = fmt.Errorf("the value:%s is invalid", tagValue) return } length, e := strconv.Atoi(sliceMetas[1]) @@ -88,7 +91,7 @@ func mockSlice(tagValue string, pvv reflect.Value) (err error) { return e } - sliceType := reflect.SliceOf(pvv.Type().Elem()) //get slice type + sliceType := reflect.SliceOf(pvv.Type().Elem()) // get slice type itemType := sliceType.Elem() // get the type of item in slice value := reflect.MakeSlice(sliceType, 0, length) newSliceValue := make([]reflect.Value, 0, length) @@ -116,7 +119,7 @@ func mockSlice(tagValue string, pvv reflect.Value) (err error) { return } -//mock bool value +// mock bool value func mockBool(tagValue string, pvv reflect.Value) (err error) { switch tagValue { case "true": @@ -129,10 +132,10 @@ func mockBool(tagValue string, pvv reflect.Value) (err error) { return } -//mock pointer +// mock pointer func mockPtr(pvv reflect.Value, ptt reflect.Type) (err error) { if pvv.IsNil() { - pvv.Set(reflect.New(ptt)) //must set nil value to zero value + pvv.Set(reflect.New(ptt)) // must set nil value to zero value } err = mock(pvv) return From b159750ef44991dab0f3937118518f6af37e1a1e Mon Sep 17 00:00:00 2001 From: ruancongyong Date: Mon, 24 May 2021 21:40:52 +0800 Subject: [PATCH 3/3] =?UTF-8?q?=E4=BF=AE=E6=94=B9changelog=E4=BF=A1?= =?UTF-8?q?=E6=81=AF=E5=92=8Cdeepsource=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CHANGELOG.md | 2 +- core/bean/mock.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 05d71682..97fa7111 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # developing -- Add: Convenient way to generate mock object [4620](https://github.com/beego/beego/issues/4397) +- Add: Convenient way to generate mock object [4620](https://github.com/beego/beego/issues/4620) - Infra: use dependabot to update dependencies. [4623](https://github.com/beego/beego/pull/4623) - Lint: use golangci-lint. [4619](https://github.com/beego/beego/pull/4619) - Chore: format code. [4615](https://github.com/beego/beego/pull/4615) diff --git a/core/bean/mock.go b/core/bean/mock.go index 707d875e..0a8d3e29 100644 --- a/core/bean/mock.go +++ b/core/bean/mock.go @@ -78,7 +78,7 @@ func mock(pv reflect.Value) (err error) { // mock slice value func mockSlice(tagValue string, pvv reflect.Value) (err error) { - if len(tagValue) == 0 { + if tagValue == "" { return } sliceMetas := strings.Split(tagValue, ":")