From eb4e44db8beee3af093b26aa94f29bff5e073699 Mon Sep 17 00:00:00 2001 From: kevindiu Date: Wed, 10 Jun 2020 16:18:16 +0900 Subject: [PATCH] fix test case --- internal/safety/safety_test.go | 258 ++++++++++++--------------------- 1 file changed, 92 insertions(+), 166 deletions(-) diff --git a/internal/safety/safety_test.go b/internal/safety/safety_test.go index 0815b310c03..720a3b8d64d 100644 --- a/internal/safety/safety_test.go +++ b/internal/safety/safety_test.go @@ -16,7 +16,6 @@ package safety import ( - "reflect" "testing" "github.com/vdaas/vald/internal/errors" @@ -24,76 +23,24 @@ import ( "go.uber.org/goleak" ) -func TestRecoverFunc(t *testing.T) { - type test struct { - name string - fn func() error - runtimeErr bool - want error - } - - tests := []test{ - { - name: "returns error when system paniced caused by runtime error", - fn: func() error { - _ = []string{}[10] - return nil - }, - runtimeErr: true, - want: errors.New("system paniced caused by runtime error: runtime error: index out of range [10] with length 0"), - }, - - { - name: "returns error when system paniced caused by panic with string value", - fn: func() error { - panic("panic") - }, - want: errors.New("panic recovered: panic"), - }, - - { - name: "returns error when system paniced caused by panic with error", - fn: func() error { - panic(errors.Errorf("error")) - }, - want: errors.New("error"), - }, - - { - name: "returns error when system paniced caused by panic with int value", - fn: func() error { - panic(10) - }, - want: errors.New("panic recovered: 10"), - }, +var ( + // Goroutine leak is detected by `fastime`, but it should be ignored in the test because it is an external package. + goleakIgnoreOptions = []goleak.Option{ + goleak.IgnoreTopFunction("github.com/kpango/fastime.(*Fastime).StartTimerD.func1"), } +) +func init() { log.Init() - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - defer func() { - if ok := tt.runtimeErr; ok { - if want, got := tt.want, recover().(error); !errors.Is(got, want) { - t.Errorf("not equals. want: %v, got: %v", want, got) - } - } - }() - - got := RecoverFunc(tt.fn)() - if !errors.Is(got, tt.want) { - t.Errorf("not equals. want: %v, got: %v", tt.want, got) - } - }) - } } -func TestRecoverWithoutPanicFunc(t *testing.T) { +func TestRecoverFunc(t *testing.T) { type args struct { fn func() error } type want struct { - want func() error + want func() error + wantPanic func() error } type test struct { name string @@ -104,116 +51,92 @@ func TestRecoverWithoutPanicFunc(t *testing.T) { afterFunc func(args) } defaultCheckFunc := func(w want, got func() error) error { - if !reflect.DeepEqual(got, w.want) { - return errors.Errorf("got = %v, want %v", got, w.want) + if (w.want == nil && got != nil) || (w.want != nil && got == nil) { + return errors.Errorf("got = %v, want %v", got, w) + } + gotErr := got() + wantErr := w.want() + if !errors.Is(gotErr, wantErr) { + return errors.Errorf("got error= %v, want error= %v", gotErr, wantErr) } return nil } tests := []test{ - // TODO test cases - /* - { - name: "test_case_1", - args: args { - fn: nil, - }, - want: want{}, - checkFunc: defaultCheckFunc, - }, - */ - - // TODO test cases - /* - func() test { - return test { - name: "test_case_2", - args: args { - fn: nil, - }, - want: want{}, - checkFunc: defaultCheckFunc, - } - }(), - */ + { + name: "returns error when system paniced caused by runtime error", + args: args{ + fn: func() error { + _ = []string{}[10] + return nil + }, + }, + want: want{ + wantPanic: func() error { + return errors.New("system paniced caused by runtime error: runtime error: index out of range [10] with length 0") + }, + }, + }, + { + name: "returns error when system paniced caused by panic with string value", + args: args{ + fn: func() error { + panic("panic") + }, + }, + want: want{ + want: func() error { + return errors.New("panic recovered: panic") + }, + }, + }, + { + name: "returns error when system paniced caused by panic with error", + args: args{ + fn: func() error { + panic(errors.Errorf("error")) + }, + }, + want: want{ + want: func() error { + return errors.Errorf("error") + }, + }, + }, + { + name: "returns error when system paniced caused by panic with int value", + args: args{ + fn: func() error { + panic(10) + }, + }, + want: want{ + want: func() error { + return errors.New("panic recovered: 10") + }, + }, + }, } for _, test := range tests { t.Run(test.name, func(tt *testing.T) { - defer goleak.VerifyNone(t) - if test.beforeFunc != nil { - test.beforeFunc(test.args) - } - if test.afterFunc != nil { - defer test.afterFunc(test.args) - } - if test.checkFunc == nil { - test.checkFunc = defaultCheckFunc - } - - got := RecoverWithoutPanicFunc(test.args.fn) - if err := test.checkFunc(test.want, got); err != nil { - tt.Errorf("error = %v", err) - } - - }) - } -} - -func Test_recoverFunc(t *testing.T) { - type args struct { - fn func() error - withPanic bool - } - type want struct { - want func() error - } - type test struct { - name string - args args - want want - checkFunc func(want, func() error) error - beforeFunc func(args) - afterFunc func(args) - } - defaultCheckFunc := func(w want, got func() error) error { - if !reflect.DeepEqual(got, w.want) { - return errors.Errorf("got = %v, want %v", got, w.want) - } - return nil - } - tests := []test{ - // TODO test cases - /* - { - name: "test_case_1", - args: args { - fn: nil, - withPanic: false, - }, - want: want{}, - checkFunc: defaultCheckFunc, - }, - */ + defer goleak.VerifyNone(tt, goleakIgnoreOptions...) - // TODO test cases - /* - func() test { - return test { - name: "test_case_2", - args: args { - fn: nil, - withPanic: false, - }, - want: want{}, - checkFunc: defaultCheckFunc, - } - }(), - */ - } + defer func(w want, tt *testing.T) { + gotPanic := recover() + if w.wantPanic == nil && gotPanic == nil { + return + } + panicErr, ok := gotPanic.(error) + if !ok { + tt.Errorf("cannot cast panic to error, panic: %v", gotPanic) + return + } + if want := w.wantPanic(); !errors.Is(want, panicErr) { + tt.Errorf("want: %v, got: %v", want, panicErr) + return + } + }(test.want, tt) - for _, test := range tests { - t.Run(test.name, func(tt *testing.T) { - defer goleak.VerifyNone(t) if test.beforeFunc != nil { test.beforeFunc(test.args) } @@ -224,11 +147,14 @@ func Test_recoverFunc(t *testing.T) { test.checkFunc = defaultCheckFunc } - got := recoverFunc(test.args.fn, test.args.withPanic) - if err := test.checkFunc(test.want, got); err != nil { - tt.Errorf("error = %v", err) + got := RecoverFunc(test.args.fn) + if test.want.wantPanic == nil { + if err := test.checkFunc(test.want, got); err != nil { + tt.Errorf("error = %v", err) + } + } else { + got() } - }) } }