This is an automated email from the ASF dual-hosted git repository. alexstocks pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/dubbo-go.git
commit 1a25a630c155a025d0ad900814cfd29417b84da2 Author: KamTo Hung <[email protected]> AuthorDate: Sun Aug 31 22:24:26 2025 +0800 fix(test): refactor variable names for clarity and consistency in tests (#2997) * fix(test): refactor variable names for clarity and consistency in tests * fix * test(default_authenticator): add test for missing access key ID in Sign method --- filter/README.md | 2 +- filter/accesslog/filter_test.go | 14 ++--- filter/active/filter_test.go | 4 +- filter/auth/accesskey_storage.go | 4 +- filter/auth/accesskey_storage_test.go | 10 ++-- filter/auth/default_authenticator.go | 6 +- filter/auth/default_authenticator_test.go | 74 ++++++++++++++---------- filter/auth/provider_auth_filter_test.go | 8 +-- filter/auth/sign_util_test.go | 11 ++-- filter/exec_limit/filter_test.go | 1 + filter/generic/filter_test.go | 8 +-- filter/generic/generalizer/protobuf_json_test.go | 22 +++---- filter/generic/service_filter_test.go | 18 +++--- filter/graceful_shutdown/consumer_filter_test.go | 14 ++--- filter/graceful_shutdown/provider_filter_test.go | 48 +++++++-------- filter/hystrix/filter_test.go | 26 ++++----- filter/seata/filter_test.go | 4 +- filter/sentinel/filter_test.go | 8 +-- filter/token/filter_test.go | 4 +- filter/tps/filter_test.go | 18 +++--- 20 files changed, 159 insertions(+), 145 deletions(-) diff --git a/filter/README.md b/filter/README.md index 5b5647de5..7ed092d12 100644 --- a/filter/README.md +++ b/filter/README.md @@ -29,7 +29,7 @@ import _ "dubbo.apache.org/dubbo-go/v3/filter/filter_impl" - execlmt: Execute Limit Filter(https://github.com/apache/dubbo-go/pull/246) - generic: Generic Filter(https://github.com/apache/dubbo-go/pull/291) - gshutdown: Graceful Shutdown Filter -- hystrix: Hystric Filter(https://github.com/apache/dubbo-go/pull/133) +- hystrix: Hystrix Filter(https://github.com/apache/dubbo-go/pull/133) - metrics: Metrics Filter(https://github.com/apache/dubbo-go/pull/342) - seata: Seata Filter - sentinel: Sentinel Filter diff --git a/filter/accesslog/filter_test.go b/filter/accesslog/filter_test.go index 727ace525..946f15a57 100644 --- a/filter/accesslog/filter_test.go +++ b/filter/accesslog/filter_test.go @@ -51,8 +51,8 @@ func TestFilter_Invoke_Not_Config(t *testing.T) { inv := invocation.NewRPCInvocation("MethodName", []any{"OK", "Hello"}, attach) accessLogFilter := &Filter{} - result := accessLogFilter.Invoke(context.Background(), invoker, inv) - assert.Nil(t, result.Error()) + invokeResult := accessLogFilter.Invoke(context.Background(), invoker, inv) + assert.Nil(t, invokeResult.Error()) } func TestFilterInvokeDefaultConfig(t *testing.T) { @@ -72,13 +72,13 @@ func TestFilterInvokeDefaultConfig(t *testing.T) { inv := invocation.NewRPCInvocation("MethodName", []any{"OK", "Hello"}, attach) accessLogFilter := &Filter{} - result := accessLogFilter.Invoke(context.Background(), invoker, inv) - assert.Nil(t, result.Error()) + invokeResult := accessLogFilter.Invoke(context.Background(), invoker, inv) + assert.Nil(t, invokeResult.Error()) } func TestFilterOnResponse(t *testing.T) { - result := &result.RPCResult{} + rpcResult := &result.RPCResult{} accessLogFilter := &Filter{} - response := accessLogFilter.OnResponse(context.TODO(), result, nil, nil) - assert.Equal(t, result, response) + response := accessLogFilter.OnResponse(context.TODO(), rpcResult, nil, nil) + assert.Equal(t, rpcResult, response) } diff --git a/filter/active/filter_test.go b/filter/active/filter_test.go index 0be112e16..7c4a69257 100644 --- a/filter/active/filter_test.go +++ b/filter/active/filter_test.go @@ -63,10 +63,10 @@ func TestFilterOnResponse(t *testing.T) { defer ctrl.Finish() invoker := mock.NewMockInvoker(ctrl) invoker.EXPECT().GetURL().Return(url).Times(1) - result := &result.RPCResult{ + rpcResult := &result.RPCResult{ Err: errors.New("test"), } - filter.OnResponse(context.TODO(), result, invoker, invoc) + filter.OnResponse(context.TODO(), rpcResult, invoker, invoc) methodStatus := base.GetMethodStatus(url, "test") urlStatus := base.GetURLStatus(url) diff --git a/filter/auth/accesskey_storage.go b/filter/auth/accesskey_storage.go index 41beb186d..14289a331 100644 --- a/filter/auth/accesskey_storage.go +++ b/filter/auth/accesskey_storage.go @@ -35,13 +35,13 @@ var ( ) func init() { - extension.SetAccessKeyStorages(constant.DefaultAccessKeyStorage, newDefaultAccesskeyStorage) + extension.SetAccessKeyStorages(constant.DefaultAccessKeyStorage, newDefaultAccessKeyStorage) } // defaultAccesskeyStorage is the default implementation of AccesskeyStorage type defaultAccesskeyStorage struct{} -func newDefaultAccesskeyStorage() filter.AccessKeyStorage { +func newDefaultAccessKeyStorage() filter.AccessKeyStorage { if storage == nil { storageOnce.Do(func() { storage = &defaultAccesskeyStorage{} diff --git a/filter/auth/accesskey_storage_test.go b/filter/auth/accesskey_storage_test.go index 897ab912d..a54982785 100644 --- a/filter/auth/accesskey_storage_test.go +++ b/filter/auth/accesskey_storage_test.go @@ -32,14 +32,14 @@ import ( "dubbo.apache.org/dubbo-go/v3/protocol/invocation" ) -func TestDefaultAccesskeyStorage_GetAccesskeyPair(t *testing.T) { - url := common.NewURLWithOptions( +func TestDefaultAccessKeyStorage_GetAccessKeyPair(t *testing.T) { + baseUrl := common.NewURLWithOptions( common.WithParams(url.Values{}), common.WithParamsValue(constant.SecretAccessKeyKey, "skey"), common.WithParamsValue(constant.AccessKeyIDKey, "akey")) inv := &invocation.RPCInvocation{} storage = &defaultAccesskeyStorage{} - accesskeyPair := storage.GetAccessKeyPair(inv, url) - assert.Equal(t, "skey", accesskeyPair.SecretKey) - assert.Equal(t, "akey", accesskeyPair.AccessKey) + accessKeyPair := storage.GetAccessKeyPair(inv, baseUrl) + assert.Equal(t, "skey", accessKeyPair.SecretKey) + assert.Equal(t, "akey", accessKeyPair.AccessKey) } diff --git a/filter/auth/default_authenticator.go b/filter/auth/default_authenticator.go index ef83b4963..9cceede2d 100644 --- a/filter/auth/default_authenticator.go +++ b/filter/auth/default_authenticator.go @@ -62,7 +62,7 @@ func (authenticator *defaultAuthenticator) Sign(inv base.Invocation, url *common consumer := url.GetParam(constant.ApplicationKey, "") accessKeyPair, err := getAccessKeyPair(inv, url) if err != nil { - return errors.New("get accesskey pair failed, cause: " + err.Error()) + return errors.New("get accessKey pair failed, cause: " + err.Error()) } rpcInv := inv.(*invocation.RPCInvocation) signature, err := getSignature(url, inv, accessKeyPair.SecretKey, currentTimeMillis) @@ -123,8 +123,8 @@ func (authenticator *defaultAuthenticator) Authenticate(inv base.Invocation, url } func getAccessKeyPair(inv base.Invocation, url *common.URL) (*filter.AccessKeyPair, error) { - accesskeyStorage := extension.GetAccessKeyStorages(url.GetParam(constant.AccessKeyStorageKey, constant.DefaultAccessKeyStorage)) - accessKeyPair := accesskeyStorage.GetAccessKeyPair(inv, url) + accessKeyStorage := extension.GetAccessKeyStorages(url.GetParam(constant.AccessKeyStorageKey, constant.DefaultAccessKeyStorage)) + accessKeyPair := accessKeyStorage.GetAccessKeyPair(inv, url) if accessKeyPair == nil || IsEmpty(accessKeyPair.AccessKey, false) || IsEmpty(accessKeyPair.SecretKey, true) { return nil, errors.New("accessKeyId or secretAccessKey not found") } else { diff --git a/filter/auth/default_authenticator_test.go b/filter/auth/default_authenticator_test.go index 997f4d02a..8e074b5e6 100644 --- a/filter/auth/default_authenticator_test.go +++ b/filter/auth/default_authenticator_test.go @@ -38,60 +38,70 @@ import ( func TestDefaultAuthenticator_Authenticate(t *testing.T) { secret := "dubbo-sk" access := "dubbo-ak" - testurl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0") - testurl.SetParam(constant.ParameterSignatureEnableKey, "true") - testurl.SetParam(constant.AccessKeyIDKey, access) - testurl.SetParam(constant.SecretAccessKeyKey, secret) - parmas := []any{"OK", struct { + testUrl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0") + testUrl.SetParam(constant.ParameterSignatureEnableKey, "true") + testUrl.SetParam(constant.AccessKeyIDKey, access) + testUrl.SetParam(constant.SecretAccessKeyKey, secret) + params := []any{"OK", struct { Name string ID int64 }{"YUYU", 1}} - inv := invocation.NewRPCInvocation("test", parmas, nil) + inv := invocation.NewRPCInvocation("test", params, nil) requestTime := strconv.Itoa(int(time.Now().Unix() * 1000)) - signature, _ := getSignature(testurl, inv, secret, requestTime) + signature, _ := getSignature(testUrl, inv, secret, requestTime) authenticator = &defaultAuthenticator{} - invcation := invocation.NewRPCInvocation("test", parmas, map[string]any{ + rpcInvocation := invocation.NewRPCInvocation("test", params, map[string]any{ constant.RequestSignatureKey: signature, constant.Consumer: "test", constant.RequestTimestampKey: requestTime, constant.AKKey: access, }) - err := authenticator.Authenticate(invcation, testurl) + err := authenticator.Authenticate(rpcInvocation, testUrl) assert.Nil(t, err) // modify the params - invcation = invocation.NewRPCInvocation("test", parmas[:1], map[string]any{ + rpcInvocation = invocation.NewRPCInvocation("test", params[:1], map[string]any{ constant.RequestSignatureKey: signature, constant.Consumer: "test", constant.RequestTimestampKey: requestTime, constant.AKKey: access, }) - err = authenticator.Authenticate(invcation, testurl) + err = authenticator.Authenticate(rpcInvocation, testUrl) assert.NotNil(t, err) } func TestDefaultAuthenticator_Sign(t *testing.T) { authenticator = &defaultAuthenticator{} - testurl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?application=test&interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0") - testurl.SetParam(constant.AccessKeyIDKey, "akey") - testurl.SetParam(constant.SecretAccessKeyKey, "skey") - testurl.SetParam(constant.ParameterSignatureEnableKey, "false") + testUrl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?application=test&interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0") + testUrl.SetParam(constant.AccessKeyIDKey, "akey") + testUrl.SetParam(constant.SecretAccessKeyKey, "skey") + testUrl.SetParam(constant.ParameterSignatureEnableKey, "false") inv := invocation.NewRPCInvocation("test", []any{"OK"}, nil) - _ = authenticator.Sign(inv, testurl) + _ = authenticator.Sign(inv, testUrl) assert.NotEqual(t, inv.GetAttachmentWithDefaultValue(constant.RequestSignatureKey, ""), "") assert.NotEqual(t, inv.GetAttachmentWithDefaultValue(constant.Consumer, ""), "") assert.NotEqual(t, inv.GetAttachmentWithDefaultValue(constant.RequestTimestampKey, ""), "") assert.Equal(t, inv.GetAttachmentWithDefaultValue(constant.AKKey, ""), "akey") } +func TestDefaultAuthenticator_SignNotAccessKeyIDKeyError(t *testing.T) { + authenticator = &defaultAuthenticator{} + testUrl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?application=test&interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0") + testUrl.SetParam(constant.SecretAccessKeyKey, "skey") + testUrl.SetParam(constant.ParameterSignatureEnableKey, "false") + inv := invocation.NewRPCInvocation("test", []any{"OK"}, nil) + err := authenticator.Sign(inv, testUrl) + assert.NotNil(t, err) +} + func Test_getAccessKeyPairSuccess(t *testing.T) { - testurl := common.NewURLWithOptions( + testUrl := common.NewURLWithOptions( common.WithParams(url.Values{}), common.WithParamsValue(constant.SecretAccessKeyKey, "skey"), common.WithParamsValue(constant.AccessKeyIDKey, "akey")) - invcation := invocation.NewRPCInvocation("MethodName", []any{"OK"}, nil) - _, e := getAccessKeyPair(invcation, testurl) + rpcInvocation := invocation.NewRPCInvocation("MethodName", []any{"OK"}, nil) + _, e := getAccessKeyPair(rpcInvocation, testUrl) assert.Nil(t, e) } @@ -100,45 +110,45 @@ func Test_getAccessKeyPairFailed(t *testing.T) { e := recover() assert.NotNil(t, e) }() - testurl := common.NewURLWithOptions( + testUrl := common.NewURLWithOptions( common.WithParams(url.Values{}), common.WithParamsValue(constant.AccessKeyIDKey, "akey")) - invcation := invocation.NewRPCInvocation("MethodName", []any{"OK"}, nil) - _, e := getAccessKeyPair(invcation, testurl) + rpcInvocation := invocation.NewRPCInvocation("MethodName", []any{"OK"}, nil) + _, e := getAccessKeyPair(rpcInvocation, testUrl) assert.NotNil(t, e) - testurl = common.NewURLWithOptions( + testUrl = common.NewURLWithOptions( common.WithParams(url.Values{}), common.WithParamsValue(constant.SecretAccessKeyKey, "skey"), common.WithParamsValue(constant.AccessKeyIDKey, "akey"), common.WithParamsValue(constant.AccessKeyStorageKey, "dubbo")) - _, e = getAccessKeyPair(invcation, testurl) + _, e = getAccessKeyPair(rpcInvocation, testUrl) assert.NoError(t, e) } func Test_getSignatureWithinParams(t *testing.T) { - testurl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0") - testurl.SetParam(constant.ParameterSignatureEnableKey, "true") + testUrl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0") + testUrl.SetParam(constant.ParameterSignatureEnableKey, "true") inv := invocation.NewRPCInvocation("test", []any{"OK"}, map[string]any{ "": "", }) secret := "dubbo" current := strconv.Itoa(int(time.Now().Unix() * 1000)) - signature, _ := getSignature(testurl, inv, secret, current) + signature, _ := getSignature(testUrl, inv, secret, current) requestString := fmt.Sprintf(constant.SignatureStringFormat, - testurl.ColonSeparatedKey(), inv.MethodName(), secret, current) + testUrl.ColonSeparatedKey(), inv.MethodName(), secret, current) s, _ := SignWithParams(inv.Arguments(), requestString, secret) assert.False(t, IsEmpty(signature, false)) assert.Equal(t, s, signature) } func Test_getSignature(t *testing.T) { - testurl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0") - testurl.SetParam(constant.ParameterSignatureEnableKey, "false") + testUrl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0") + testUrl.SetParam(constant.ParameterSignatureEnableKey, "false") inv := invocation.NewRPCInvocation("test", []any{"OK"}, nil) secret := "dubbo" current := strconv.Itoa(int(time.Now().Unix() * 1000)) - signature, _ := getSignature(testurl, inv, secret, current) + signature, _ := getSignature(testUrl, inv, secret, current) requestString := fmt.Sprintf(constant.SignatureStringFormat, - testurl.ColonSeparatedKey(), inv.MethodName(), secret, current) + testUrl.ColonSeparatedKey(), inv.MethodName(), secret, current) s := Sign(requestString, secret) assert.False(t, IsEmpty(signature, false)) assert.Equal(t, s, signature) diff --git a/filter/auth/provider_auth_filter_test.go b/filter/auth/provider_auth_filter_test.go index 789603a4d..0465c06fe 100644 --- a/filter/auth/provider_auth_filter_test.go +++ b/filter/auth/provider_auth_filter_test.go @@ -65,10 +65,10 @@ func TestProviderAuthFilter_Invoke(t *testing.T) { filter := &authFilter{} defer ctrl.Finish() invoker := mock.NewMockInvoker(ctrl) - result := &result.RPCResult{} - invoker.EXPECT().Invoke(context.Background(), inv).Return(result).Times(2) + rpcResult := &result.RPCResult{} + invoker.EXPECT().Invoke(context.Background(), inv).Return(rpcResult).Times(2) invoker.EXPECT().GetURL().Return(url).Times(2) - assert.Equal(t, result, filter.Invoke(context.Background(), invoker, inv)) + assert.Equal(t, rpcResult, filter.Invoke(context.Background(), invoker, inv)) url.SetParam(constant.ServiceAuthKey, "true") - assert.Equal(t, result, filter.Invoke(context.Background(), invoker, inv)) + assert.Equal(t, rpcResult, filter.Invoke(context.Background(), invoker, inv)) } diff --git a/filter/auth/sign_util_test.go b/filter/auth/sign_util_test.go index 02e36853e..80b25dd04 100644 --- a/filter/auth/sign_util_test.go +++ b/filter/auth/sign_util_test.go @@ -35,7 +35,6 @@ func TestIsEmpty(t *testing.T) { args args want bool }{ - // TODO: Add test cases. {"whitespace_false", args{s: " ", allowSpace: false}, true}, {"whitespace_true", args{s: " ", allowSpace: true}, false}, {"normal_false", args{s: "hello,dubbo", allowSpace: false}, false}, @@ -80,7 +79,8 @@ func TestSignWithParams(t *testing.T) { ID int64 }{"YuYu", 1}, } - signature, _ := SignWithParams(params, metadata, key) + signature, err := SignWithParams(params, metadata, key) + assert.NoError(t, err) assert.False(t, IsEmpty(signature, false)) } @@ -106,8 +106,11 @@ func Test_toBytes(t *testing.T) { ID int64 }{"YuYu", 1}, } - jsonBytes, _ := toBytes(params) - jsonBytes2, _ := toBytes(params2) + jsonBytes, err := toBytes(params) + assert.NoError(t, err) assert.NotNil(t, jsonBytes) + jsonBytes2, err2 := toBytes(params2) + assert.NoError(t, err2) + assert.NotNil(t, jsonBytes2) assert.Equal(t, jsonBytes, jsonBytes2) } diff --git a/filter/exec_limit/filter_test.go b/filter/exec_limit/filter_test.go index 3397b8810..93322260f 100644 --- a/filter/exec_limit/filter_test.go +++ b/filter/exec_limit/filter_test.go @@ -62,6 +62,7 @@ func TestFilterInvokeConfigureError(t *testing.T) { limitFilter := newFilter() result := limitFilter.Invoke(context.Background(), base.NewBaseInvoker(invokeUrl), invoc) + assert.NotNil(t, result) assert.Nil(t, result.Error()) } diff --git a/filter/generic/filter_test.go b/filter/generic/filter_test.go index ab839b40a..a301f08a4 100644 --- a/filter/generic/filter_test.go +++ b/filter/generic/filter_test.go @@ -65,8 +65,8 @@ func TestFilter_Invoke(t *testing.T) { return &result.RPCResult{} }) - result := filter.Invoke(context.Background(), mockInvoker, normalInvocation) - assert.NotNil(t, result) + r := filter.Invoke(context.Background(), mockInvoker, normalInvocation) + assert.NotNil(t, r) } // test isMakingAGenericCall branch @@ -98,6 +98,6 @@ func TestFilter_InvokeWithGenericCall(t *testing.T) { return &result.RPCResult{} }) - result := filter.Invoke(context.Background(), mockInvoker, genericInvocation) - assert.NotNil(t, result) + r := filter.Invoke(context.Background(), mockInvoker, genericInvocation) + assert.NotNil(t, r) } diff --git a/filter/generic/generalizer/protobuf_json_test.go b/filter/generic/generalizer/protobuf_json_test.go index 7103141cb..5a6f92a93 100644 --- a/filter/generic/generalizer/protobuf_json_test.go +++ b/filter/generic/generalizer/protobuf_json_test.go @@ -32,13 +32,13 @@ func TestProtobufJsonGeneralizer(t *testing.T) { req := &RequestType{ Id: 1, } - reqjson, err := g.Generalize(req) + reqJson, err := g.Generalize(req) assert.Nil(t, err) - rreq, err := g.Realize(reqjson, reflect.TypeOf(req)) + rReq, err := g.Realize(reqJson, reflect.TypeOf(req)) assert.Nil(t, err) - reqobj, ok := rreq.(*RequestType) + reqObj, ok := rReq.(*RequestType) assert.True(t, ok) - assert.Equal(t, req.Id, reqobj.GetId()) + assert.Equal(t, req.Id, reqObj.GetId()) resp := &ResponseType{ Code: 200, @@ -46,14 +46,14 @@ func TestProtobufJsonGeneralizer(t *testing.T) { Name: "xavierniu", Message: "Nice to meet you", } - respjson, err := g.Generalize(resp) + respJson, err := g.Generalize(resp) assert.Nil(t, err) - rresp, err := g.Realize(respjson, reflect.TypeOf(resp)) + rResp, err := g.Realize(respJson, reflect.TypeOf(resp)) assert.Nil(t, err) - respobj, ok := rresp.(*ResponseType) + respObj, ok := rResp.(*ResponseType) assert.True(t, ok) - assert.Equal(t, resp.Code, respobj.GetCode()) - assert.Equal(t, resp.Id, respobj.GetId()) - assert.Equal(t, resp.Name, respobj.GetName()) - assert.Equal(t, resp.Message, respobj.GetMessage()) + assert.Equal(t, resp.Code, respObj.GetCode()) + assert.Equal(t, resp.Id, respObj.GetId()) + assert.Equal(t, resp.Name, respObj.GetName()) + assert.Equal(t, resp.Message, respObj.GetMessage()) } diff --git a/filter/generic/service_filter_test.go b/filter/generic/service_filter_test.go index 5fa210823..a68723dce 100644 --- a/filter/generic/service_filter_test.go +++ b/filter/generic/service_filter_test.go @@ -171,19 +171,19 @@ func TestServiceFilter_Invoke(t *testing.T) { } }).AnyTimes() - result := filter.Invoke(context.Background(), mockInvoker, invocation4) - assert.Nil(t, result.Error()) - assert.Equal(t, "hello, world", result.Result()) + invokeResult := filter.Invoke(context.Background(), mockInvoker, invocation4) + assert.Nil(t, invokeResult.Error()) + assert.Equal(t, "hello, world", invokeResult.Result()) - result = filter.Invoke(context.Background(), mockInvoker, invocation5) + invokeResult = filter.Invoke(context.Background(), mockInvoker, invocation5) assert.Equal(t, fmt.Sprintf("\"hello11\" method is not found, service key: %s", ivkUrl.ServiceKey()), - fmt.Sprintf("%v", result.Error())) + fmt.Sprintf("%v", invokeResult.Error())) - result = filter.Invoke(context.Background(), mockInvoker, invocation6) + invokeResult = filter.Invoke(context.Background(), mockInvoker, invocation6) assert.Equal(t, "the number of args(=2) is not matched with \"Hello\" method", - fmt.Sprintf("%v", result.Error())) + fmt.Sprintf("%v", invokeResult.Error())) //result = filter.Invoke(context.Background(), mockInvoker, invocation7) //assert.Equal(t, int64(200), result.Result().(*generalizer.ResponseType).GetCode()) @@ -210,6 +210,6 @@ func TestServiceFilter_OnResponse(t *testing.T) { Rest: "result", } - result := filter.OnResponse(context.Background(), rpcResult, nil, invocation1) - assert.Equal(t, "result", result.Result()) + response := filter.OnResponse(context.Background(), rpcResult, nil, invocation1) + assert.Equal(t, "result", response.Result()) } diff --git a/filter/graceful_shutdown/consumer_filter_test.go b/filter/graceful_shutdown/consumer_filter_test.go index f910fe7b2..9a368336b 100644 --- a/filter/graceful_shutdown/consumer_filter_test.go +++ b/filter/graceful_shutdown/consumer_filter_test.go @@ -39,8 +39,8 @@ import ( func TestConsumerFilterInvokeWithGlobalPackage(t *testing.T) { var ( - url = common.NewURLWithOptions(common.WithParams(url.Values{})) - invocation = invocation.NewRPCInvocation("GetUser", []any{"OK"}, make(map[string]any)) + baseUrl = common.NewURLWithOptions(common.WithParams(url.Values{})) + rpcInvocation = invocation.NewRPCInvocation("GetUser", []any{"OK"}, make(map[string]any)) opt = graceful_shutdown.NewOptions() filterValue, _ = extension.GetFilter(constant.GracefulShutdownConsumerFilterKey) ) @@ -51,7 +51,7 @@ func TestConsumerFilterInvokeWithGlobalPackage(t *testing.T) { filter.Set(constant.GracefulShutdownFilterShutdownConfig, opt.Shutdown) assert.Equal(t, filter.shutdownConfig, opt.Shutdown) - result := filter.Invoke(context.Background(), base.NewBaseInvoker(url), invocation) + result := filter.Invoke(context.Background(), base.NewBaseInvoker(baseUrl), rpcInvocation) assert.NotNil(t, result) assert.Nil(t, result.Error()) } @@ -59,9 +59,9 @@ func TestConsumerFilterInvokeWithGlobalPackage(t *testing.T) { // only for compatibility with old config, able to directly remove after config is deleted func TestConsumerFilterInvokeWithConfigPackage(t *testing.T) { var ( - url = common.NewURLWithOptions(common.WithParams(url.Values{})) - invocation = invocation.NewRPCInvocation("GetUser", []any{"OK"}, make(map[string]any)) - rootConfig = config.NewRootConfigBuilder(). + baseUrl = common.NewURLWithOptions(common.WithParams(url.Values{})) + rpcInvocation = invocation.NewRPCInvocation("GetUser", []any{"OK"}, make(map[string]any)) + rootConfig = config.NewRootConfigBuilder(). SetShutDown(config.NewShutDownConfigBuilder(). SetTimeout("60s"). SetStepTimeout("3s"). @@ -75,7 +75,7 @@ func TestConsumerFilterInvokeWithConfigPackage(t *testing.T) { filter.Set(constant.GracefulShutdownFilterShutdownConfig, config.GetShutDown()) assert.Equal(t, filter.shutdownConfig, compatGlobalShutdownConfig(config.GetShutDown())) - result := filter.Invoke(context.Background(), base.NewBaseInvoker(url), invocation) + result := filter.Invoke(context.Background(), base.NewBaseInvoker(baseUrl), rpcInvocation) assert.NotNil(t, result) assert.Nil(t, result.Error()) } diff --git a/filter/graceful_shutdown/provider_filter_test.go b/filter/graceful_shutdown/provider_filter_test.go index 10830f94a..33ce16d8d 100644 --- a/filter/graceful_shutdown/provider_filter_test.go +++ b/filter/graceful_shutdown/provider_filter_test.go @@ -43,8 +43,8 @@ import ( func TestProviderFilterInvokeWithGlobalPackage(t *testing.T) { var ( - url = common.NewURLWithOptions(common.WithParams(url.Values{})) - invocation = invocation.NewRPCInvocation("GetUser", []any{"OK"}, make(map[string]any)) + baseUrl = common.NewURLWithOptions(common.WithParams(url.Values{})) + rpcInvocation = invocation.NewRPCInvocation("GetUser", []any{"OK"}, make(map[string]any)) opt = graceful_shutdown.NewOptions() filterValue, _ = extension.GetFilter(constant.GracefulShutdownProviderFilterKey) ) @@ -55,26 +55,26 @@ func TestProviderFilterInvokeWithGlobalPackage(t *testing.T) { opt.Shutdown.RejectRequestHandler = "test" - filter := filterValue.(*providerGracefulShutdownFilter) - filter.Set(constant.GracefulShutdownFilterShutdownConfig, opt.Shutdown) - assert.Equal(t, filter.shutdownConfig, opt.Shutdown) + providerFilter := filterValue.(*providerGracefulShutdownFilter) + providerFilter.Set(constant.GracefulShutdownFilterShutdownConfig, opt.Shutdown) + assert.Equal(t, providerFilter.shutdownConfig, opt.Shutdown) - result := filter.Invoke(context.Background(), base.NewBaseInvoker(url), invocation) - assert.NotNil(t, result) - assert.Nil(t, result.Error()) + invokeResult := providerFilter.Invoke(context.Background(), base.NewBaseInvoker(baseUrl), rpcInvocation) + assert.NotNil(t, invokeResult) + assert.Nil(t, invokeResult.Error()) opt.Shutdown.RejectRequest.Store(true) - result = filter.Invoke(context.Background(), base.NewBaseInvoker(url), invocation) - assert.NotNil(t, result) - assert.NotNil(t, result.Error().Error(), "Rejected") + invokeResult = providerFilter.Invoke(context.Background(), base.NewBaseInvoker(baseUrl), rpcInvocation) + assert.NotNil(t, invokeResult) + assert.NotNil(t, invokeResult.Error().Error(), "Rejected") } // only for compatibility with old config, able to directly remove after config is deleted func TestProviderFilterInvokeWithConfigPackage(t *testing.T) { var ( - url = common.NewURLWithOptions(common.WithParams(url.Values{})) - invocation = invocation.NewRPCInvocation("GetUser", []any{"OK"}, make(map[string]any)) - rootConfig = config.NewRootConfigBuilder(). + baseUrl = common.NewURLWithOptions(common.WithParams(url.Values{})) + rpcInvocation = invocation.NewRPCInvocation("GetUser", []any{"OK"}, make(map[string]any)) + rootConfig = config.NewRootConfigBuilder(). SetShutDown(config.NewShutDownConfigBuilder(). SetTimeout("60s"). SetStepTimeout("3s"). @@ -89,22 +89,22 @@ func TestProviderFilterInvokeWithConfigPackage(t *testing.T) { config.SetRootConfig(*rootConfig) - filter := filterValue.(*providerGracefulShutdownFilter) - filter.Set(constant.GracefulShutdownFilterShutdownConfig, config.GetShutDown()) - assert.Equal(t, filter.shutdownConfig, compatGlobalShutdownConfig(config.GetShutDown())) + providerFilter := filterValue.(*providerGracefulShutdownFilter) + providerFilter.Set(constant.GracefulShutdownFilterShutdownConfig, config.GetShutDown()) + assert.Equal(t, providerFilter.shutdownConfig, compatGlobalShutdownConfig(config.GetShutDown())) - result := filter.Invoke(context.Background(), base.NewBaseInvoker(url), invocation) - assert.NotNil(t, result) - assert.Nil(t, result.Error()) + invokeResult := providerFilter.Invoke(context.Background(), base.NewBaseInvoker(baseUrl), rpcInvocation) + assert.NotNil(t, invokeResult) + assert.Nil(t, invokeResult.Error()) // only use this way to set the RejectRequest, because the variable is compact to GlobalShutdownConfig - filter.shutdownConfig.RejectRequest.Store(true) + providerFilter.shutdownConfig.RejectRequest.Store(true) // not able to use this way to set the RejectRequest //config.GetShutDown().RejectRequest.Store(true) - result = filter.Invoke(context.Background(), base.NewBaseInvoker(url), invocation) - assert.NotNil(t, result) - assert.NotNil(t, result.Error().Error(), "Rejected") + invokeResult = providerFilter.Invoke(context.Background(), base.NewBaseInvoker(baseUrl), rpcInvocation) + assert.NotNil(t, invokeResult) + assert.NotNil(t, invokeResult.Error().Error(), "Rejected") } type TestRejectedExecutionHandler struct{} diff --git a/filter/hystrix/filter_test.go b/filter/hystrix/filter_test.go index e95ed3518..90b329c73 100644 --- a/filter/hystrix/filter_test.go +++ b/filter/hystrix/filter_test.go @@ -157,10 +157,10 @@ func TestHystrixFilterInvokeSuccess(t *testing.T) { fmt.Sprintf("dubbo://%s:%d/com.ikurento.user.UserProvider", constant.LocalHostValue, constant.DefaultPort)) assert.NoError(t, err) testInvoker := testMockSuccessInvoker{*base.NewBaseInvoker(testUrl)} - result := hf.Invoke(context.Background(), &testInvoker, &invocation.RPCInvocation{}) - assert.NotNil(t, result) - assert.NoError(t, result.Error()) - assert.NotNil(t, result.Result()) + invokeResult := hf.Invoke(context.Background(), &testInvoker, &invocation.RPCInvocation{}) + assert.NotNil(t, invokeResult) + assert.NoError(t, invokeResult.Error()) + assert.NotNil(t, invokeResult.Result()) } func TestHystrixFilterInvokeFail(t *testing.T) { @@ -169,12 +169,12 @@ func TestHystrixFilterInvokeFail(t *testing.T) { fmt.Sprintf("dubbo://%s:%d/com.ikurento.user.UserProvider", constant.LocalHostValue, constant.DefaultPort)) assert.NoError(t, err) testInvoker := testMockFailInvoker{*base.NewBaseInvoker(testUrl)} - result := hf.Invoke(context.Background(), &testInvoker, &invocation.RPCInvocation{}) - assert.NotNil(t, result) - assert.Error(t, result.Error()) + invokeResult := hf.Invoke(context.Background(), &testInvoker, &invocation.RPCInvocation{}) + assert.NotNil(t, invokeResult) + assert.Error(t, invokeResult.Error()) } -func TestHystricFilterInvokeCircuitBreak(t *testing.T) { +func TestHystrixFilterInvokeCircuitBreak(t *testing.T) { mockInitHystrixConfig() hystrix.Flush() hf := &Filter{COrP: true} @@ -185,8 +185,8 @@ func TestHystricFilterInvokeCircuitBreak(t *testing.T) { fmt.Sprintf("dubbo://%s:%d/com.ikurento.user.UserProvider", constant.LocalHostValue, constant.DefaultPort)) assert.NoError(t, err) testInvoker := testMockSuccessInvoker{*base.NewBaseInvoker(testUrl)} - result := hf.Invoke(context.Background(), &testInvoker, &invocation.RPCInvocation{}) - resChan <- result + invokeResult := hf.Invoke(context.Background(), &testInvoker, &invocation.RPCInvocation{}) + resChan <- invokeResult }() } // This can not always pass the test when on travis due to concurrency, you can uncomment the code below and test it locally @@ -200,7 +200,7 @@ func TestHystricFilterInvokeCircuitBreak(t *testing.T) { //assert.True(t, lastRest) } -func TestHystricFilterInvokeCircuitBreakOmitException(t *testing.T) { +func TestHystrixFilterInvokeCircuitBreakOmitException(t *testing.T) { mockInitHystrixConfig() hystrix.Flush() reg, _ := regexp.Compile(".*exception.*") @@ -213,8 +213,8 @@ func TestHystricFilterInvokeCircuitBreakOmitException(t *testing.T) { fmt.Sprintf("dubbo://%s:%d/com.ikurento.user.UserProvider", constant.LocalHostValue, constant.DefaultPort)) assert.NoError(t, err) testInvoker := testMockSuccessInvoker{*base.NewBaseInvoker(testUrl)} - result := hf.Invoke(context.Background(), &testInvoker, &invocation.RPCInvocation{}) - resChan <- result + invokeResult := hf.Invoke(context.Background(), &testInvoker, &invocation.RPCInvocation{}) + resChan <- invokeResult }() } // This can not always pass the test when on travis due to concurrency, you can uncomment the code below and test it locally diff --git a/filter/seata/filter_test.go b/filter/seata/filter_test.go index b84ef16d5..3913a8480 100644 --- a/filter/seata/filter_test.go +++ b/filter/seata/filter_test.go @@ -49,9 +49,9 @@ func (iv *testMockSeataInvoker) Invoke(ctx context.Context, _ base.Invocation) r func TestSeataFilter_Invoke(t *testing.T) { filter := &seataFilter{} - result := filter.Invoke(context.Background(), &testMockSeataInvoker{}, invocation.NewRPCInvocation("$echo", + invokeResult := filter.Invoke(context.Background(), &testMockSeataInvoker{}, invocation.NewRPCInvocation("$echo", []any{"OK"}, map[string]any{ string(SEATA_XID): "10.30.21.227:8091:2000047792", })) - assert.Equal(t, "10.30.21.227:8091:2000047792", result.Result()) + assert.Equal(t, "10.30.21.227:8091:2000047792", invokeResult.Result()) } diff --git a/filter/sentinel/filter_test.go b/filter/sentinel/filter_test.go index c0227361b..555befc5a 100644 --- a/filter/sentinel/filter_test.go +++ b/filter/sentinel/filter_test.go @@ -147,8 +147,8 @@ func TestSentinelFilter_ErrorCount(t *testing.T) { f := &sentinelProviderFilter{} for i := 0; i < 50; i++ { - result := f.Invoke(context.TODO(), mockInvoker, mockInvocation) - assert.Error(t, result.Error()) + invokeResult := f.Invoke(context.TODO(), mockInvoker, mockInvocation) + assert.Error(t, invokeResult.Error()) } select { case <-time.After(time.Second): @@ -182,8 +182,8 @@ func TestProviderFilter_Invoke(t *testing.T) { assert.NoError(t, err) mockInvoker := base.NewBaseInvoker(url) mockInvocation := invocation.NewRPCInvocation("hello", []any{"OK"}, make(map[string]any)) - result := f.Invoke(context.TODO(), mockInvoker, mockInvocation) - assert.NoError(t, result.Error()) + invokeResult := f.Invoke(context.TODO(), mockInvoker, mockInvocation) + assert.NoError(t, invokeResult.Error()) } func TestGetResourceName(t *testing.T) { diff --git a/filter/token/filter_test.go b/filter/token/filter_test.go index a285921d9..2a77c8674 100644 --- a/filter/token/filter_test.go +++ b/filter/token/filter_test.go @@ -37,13 +37,13 @@ import ( func TestTokenFilterInvoke(t *testing.T) { filter := &tokenFilter{} - url := common.NewURLWithOptions( + baseUrl := common.NewURLWithOptions( common.WithParams(url.Values{}), common.WithParamsValue(constant.TokenKey, "ori_key")) attch := make(map[string]any) attch[constant.TokenKey] = "ori_key" result := filter.Invoke(context.Background(), - base.NewBaseInvoker(url), + base.NewBaseInvoker(baseUrl), invocation.NewRPCInvocation("MethodName", []any{"OK"}, attch)) assert.Nil(t, result.Error()) diff --git a/filter/tps/filter_test.go b/filter/tps/filter_test.go index f02d9e52a..1369eb0cc 100644 --- a/filter/tps/filter_test.go +++ b/filter/tps/filter_test.go @@ -48,12 +48,12 @@ func TestTpsLimitFilterInvokeWithNoTpsLimiter(t *testing.T) { common.WithParamsValue(constant.TPSLimiterKey, "")) attch := make(map[string]any) - result := tpsFilter.Invoke(context.Background(), + invokeResult := tpsFilter.Invoke(context.Background(), base.NewBaseInvoker(invokeUrl), invocation.NewRPCInvocation("MethodName", []any{"OK"}, attch)) - assert.Nil(t, result.Error()) - assert.Nil(t, result.Result()) + assert.Nil(t, invokeResult.Error()) + assert.Nil(t, invokeResult.Result()) } func TestGenericFilterInvokeWithDefaultTpsLimiter(t *testing.T) { @@ -71,12 +71,12 @@ func TestGenericFilterInvokeWithDefaultTpsLimiter(t *testing.T) { common.WithParamsValue(constant.TPSLimiterKey, constant.DefaultKey)) attch := make(map[string]any) - result := tpsFilter.Invoke(context.Background(), + invokeResult := tpsFilter.Invoke(context.Background(), base.NewBaseInvoker(invokeUrl), invocation.NewRPCInvocation("MethodName", []any{"OK"}, attch)) - assert.Nil(t, result.Error()) - assert.Nil(t, result.Result()) + assert.Nil(t, invokeResult.Error()) + assert.Nil(t, invokeResult.Result()) } func TestGenericFilterInvokeWithDefaultTpsLimiterNotAllow(t *testing.T) { @@ -102,9 +102,9 @@ func TestGenericFilterInvokeWithDefaultTpsLimiterNotAllow(t *testing.T) { common.WithParamsValue(constant.TPSLimiterKey, constant.DefaultKey)) attch := make(map[string]any) - result := tpsFilter.Invoke(context.Background(), + invokeResult := tpsFilter.Invoke(context.Background(), base.NewBaseInvoker(invokeUrl), invocation.NewRPCInvocation("MethodName", []any{"OK"}, attch)) - assert.Nil(t, result.Error()) - assert.Nil(t, result.Result()) + assert.Nil(t, invokeResult.Error()) + assert.Nil(t, invokeResult.Result()) }
