Tst:test for common

common/proxy/proxy.go

@@ -53,18 +53,26 @@ func (p *Proxy) Implement(v common.RPCService) {
 
 	makeDubboCallProxy := func(methodName string, outs []reflect.Type) func(in []reflect.Value) []reflect.Value {
 		return func(in []reflect.Value) []reflect.Value {
-
+			var (
+				err error
+				inv *invocation_impl.RPCInvocation
+			)
 			if methodName == "Echo" {
 				methodName = "$echo"
 			}
-			inv := invocation_impl.NewRPCInvocationForConsumer(methodName, nil, in[1].Interface().([]interface{}), in[2].Interface(), p.callBack, common.URL{}, nil)
+			if len(in) == 2 {
+				inv = invocation_impl.NewRPCInvocationForConsumer(methodName, nil, in[0].Interface().([]interface{}), in[1].Interface(), p.callBack, common.URL{}, nil)
+			}
+			if len(in) == 3 {
+				inv = invocation_impl.NewRPCInvocationForConsumer(methodName, nil, in[1].Interface().([]interface{}), in[2].Interface(), p.callBack, common.URL{}, nil)
+			}
 
 			for k, v := range p.attachments {
 				inv.SetAttachments(k, v)
 			}
 
 			result := p.invoke.Invoke(inv)
-			var err error
+
 			err = result.Error()
 			log.Info("[makeDubboCallProxy] err: %v", err)
 			return []reflect.Value{reflect.ValueOf(&err).Elem()}
@@ -76,20 +84,19 @@ func (p *Proxy) Implement(v common.RPCService) {
 		t := typeOf.Field(i)
 		f := valueOfElem.Field(i)
 		if f.Kind() == reflect.Func && f.IsValid() && f.CanSet() {
-
-			if t.Type.NumIn() != 3 && t.Type.NumIn() != 4 {
+			if t.Type.NumIn() != 2 && t.Type.NumIn() != 3 {
 				log.Warn("method %s of mtype %v has wrong number of in parameters %d; needs exactly 3/4",
 					t.Name, t.Type.String(), t.Type.NumIn())
 				continue
 			}
 
-			if t.Type.NumIn() == 3 && t.Type.In(2).Kind() != reflect.Ptr {
-				log.Warn("reply type of method %q is not a pointer %v", t.Name, t.Type.In(2))
+			if t.Type.NumIn() == 2 && t.Type.In(1).Kind() != reflect.Ptr {
+				log.Warn("reply type of method %q is not a pointer %v", t.Name, t.Type.In(1))
 				continue
 			}
 
-			if t.Type.NumIn() == 4 && t.Type.In(3).Kind() != reflect.Ptr {
-				log.Warn("reply type of method %q is not a pointer %v", t.Name, t.Type.In(3))
+			if t.Type.NumIn() == 3 && t.Type.In(2).Kind() != reflect.Ptr {
+				log.Warn("reply type of method %q is not a pointer %v", t.Name, t.Type.In(2))
 				continue
 			}
 

common/proxy/proxy_test.go

@@ -34,7 +34,7 @@ func TestProxy_Implement(t *testing.T) {
 		return errors.New("errors")
 	}}
 	p.Implement(s)
-	err := s.MethodOne(nil, nil, nil)
+	err := p.Get().(*TestService).MethodOne(nil, nil, nil)
 	assert.NoError(t, err)
 
 	// inherit & lowercase
@@ -54,12 +54,11 @@ func TestProxy_Implement(t *testing.T) {
 	// args number
 	type S2 struct {
 		TestService
-		MethodOne func(context.Context, []interface{}) error
+		MethodOne func([]interface{}) error
 	}
 	s2 := &S2{TestService: *s}
 	p.Implement(s2)
 	assert.Nil(t, s2.MethodOne)
-	//assert.EqualError(t, err, "method MethodOne of mtype func(context.Context, []interface {}) error has wrong number of in parameters 2; needs exactly 3/4")
 
 	// returns number
 	type S3 struct {
@@ -69,7 +68,6 @@ func TestProxy_Implement(t *testing.T) {
 	s3 := &S3{TestService: *s}
 	p.Implement(s3)
 	assert.Nil(t, s3.MethodOne)
-	//assert.EqualError(t, err, "method \"MethodOne\" has 2 out parameters; needs exactly 1")
 
 	// returns type
 	type S4 struct {
@@ -79,9 +77,8 @@ func TestProxy_Implement(t *testing.T) {
 	s4 := &S4{TestService: *s}
 	p.Implement(s4)
 	assert.Nil(t, s4.MethodOne)
-	//assert.EqualError(t, err, "return type interface {} of method \"MethodOne\" is not error")
 
-	// reply type
+	// reply type for number 3
 	type S5 struct {
 		TestService
 		MethodOne func(context.Context, []interface{}, interface{}) error
@@ -89,6 +86,13 @@ func TestProxy_Implement(t *testing.T) {
 	s5 := &S5{TestService: *s}
 	p.Implement(s5)
 	assert.Nil(t, s5.MethodOne)
-	//assert.EqualError(t, err, "reply type of method \"MethodOne\" is not a pointer interface {}")
 
+	// reply type for number 2
+	type S6 struct {
+		TestService
+		MethodOne func([]interface{}, interface{}) error
+	}
+	s6 := &S6{TestService: *s}
+	p.Implement(s6)
+	assert.Nil(t, s5.MethodOne)
 }

common/rpc_service_test.go

@@ -2,6 +2,7 @@ package common
 
 import (
 	"context"
+	"reflect"
 	"testing"
 )
 
@@ -15,12 +16,10 @@ type TestService struct {
 func (s *TestService) MethodOne(ctx context.Context, args []interface{}, rsp *struct{}) error {
 	return nil
 }
-
-func (s *TestService) MethodTwo(ctx context.Context, args []interface{}, rsp *struct{}) error {
+func (s *TestService) MethodTwo(args []interface{}, rsp *struct{}) error {
 	return nil
 
 }
-
 func (s *TestService) Service() string {
 	return "com.test.Path"
 }
@@ -28,9 +27,132 @@ func (s *TestService) Version() string {
 	return ""
 }
 
+type testService struct {
+}
+
+func (s *testService) Method1(ctx context.Context, args testService, rsp *struct{}) error {
+	return nil
+}
+func (s *testService) Method2(ctx context.Context, args []interface{}, rsp struct{}) error {
+	return nil
+}
+func (s *testService) Method3(ctx context.Context, args []interface{}, rsp *testService) error {
+	return nil
+}
+func (s *testService) Method4(ctx context.Context, args []interface{}, rsp *struct{}) {
+}
+func (s *testService) Method5(ctx context.Context, args []interface{}, rsp *struct{}) *testService {
+	return nil
+}
+func (s *testService) Service() string {
+	return "com.test.Path"
+}
+func (s *testService) Version() string {
+	return ""
+}
+
+type TestService1 struct {
+}
+
+func (s *TestService1) Service() string {
+	return "com.test.Path1"
+}
+func (s *TestService1) Version() string {
+	return ""
+}
+
 func TestServiceMap_Register(t *testing.T) {
+	// lowercase
+	s0 := &testService{}
+	methods, err := ServiceMap.Register("testporotocol", s0)
+	assert.EqualError(t, err, "type testService is not exported")
+
+	// succ
 	s := &TestService{}
-	methods, err := ServiceMap.Register("testporotocol", s)
+	methods, err = ServiceMap.Register("testporotocol", s)
 	assert.NoError(t, err)
 	assert.Equal(t, "MethodOne,MethodTwo", methods)
+
+	// repeat
+	methods, err = ServiceMap.Register("testporotocol", s)
+	assert.EqualError(t, err, "service already defined: com.test.Path")
+
+	// no method
+	s1 := &TestService1{}
+	methods, err = ServiceMap.Register("testporotocol", s1)
+	assert.EqualError(t, err, "type com.test.Path1 has no exported methods of suitable type")
+}
+
+func TestMethodType_SuiteContext(t *testing.T) {
+	mt := &MethodType{ctxType: reflect.TypeOf(context.TODO())}
+	c := context.TODO()
+	c = context.WithValue(c, "key", "value")
+	assert.Equal(t, reflect.ValueOf(c), mt.SuiteContext(c))
+
+	assert.Equal(t, reflect.Zero(mt.ctxType), mt.SuiteContext(nil))
+}
+
+func TestSuiteMethod(t *testing.T) {
+	// 4
+	s := &TestService{}
+	method, ok := reflect.TypeOf(s).MethodByName("MethodOne")
+	assert.True(t, ok)
+	methodType := suiteMethod(method)
+	method = methodType.Method()
+	assert.Equal(t, "func(*common.TestService, context.Context, []interface {}, *struct {}) error", method.Type.String())
+	at := methodType.ArgType()
+	assert.Equal(t, "[]interface {}", at.String())
+	ct := methodType.CtxType()
+	assert.Equal(t, "context.Context", ct.String())
+	rt := methodType.ReplyType()
+	assert.Equal(t, "*struct {}", rt.String())
+
+	// 3
+	method, ok = reflect.TypeOf(s).MethodByName("MethodTwo")
+	assert.True(t, ok)
+	methodType = suiteMethod(method)
+	method = methodType.Method()
+	assert.Equal(t, "func(*common.TestService, []interface {}, *struct {}) error", method.Type.String())
+	at = methodType.ArgType()
+	assert.Equal(t, "[]interface {}", at.String())
+	assert.Nil(t, methodType.CtxType())
+	rt = methodType.ReplyType()
+	assert.Equal(t, "*struct {}", rt.String())
+
+	// wrong number of in parameters
+	s1 := &testService{}
+	method, ok = reflect.TypeOf(s1).MethodByName("Version")
+	assert.True(t, ok)
+	methodType = suiteMethod(method)
+	assert.Nil(t, methodType)
+
+	// args not exported
+	method, ok = reflect.TypeOf(s1).MethodByName("Method1")
+	assert.True(t, ok)
+	methodType = suiteMethod(method)
+	assert.Nil(t, methodType)
+
+	// replyType != Ptr
+	method, ok = reflect.TypeOf(s1).MethodByName("Method2")
+	assert.True(t, ok)
+	methodType = suiteMethod(method)
+	assert.Nil(t, methodType)
+
+	// Reply not exported
+	method, ok = reflect.TypeOf(s1).MethodByName("Method3")
+	assert.True(t, ok)
+	methodType = suiteMethod(method)
+	assert.Nil(t, methodType)
+
+	// no return
+	method, ok = reflect.TypeOf(s1).MethodByName("Method4")
+	assert.True(t, ok)
+	methodType = suiteMethod(method)
+	assert.Nil(t, methodType)
+
+	// return value is not error
+	method, ok = reflect.TypeOf(s1).MethodByName("Method5")
+	assert.True(t, ok)
+	methodType = suiteMethod(method)
+	assert.Nil(t, methodType)
 }

common/url.go

@@ -216,9 +216,7 @@ func (c URL) String() string {
 	buildString := fmt.Sprintf(
 		"%s://%s:%s@%s:%s%s?",
 		c.Protocol, c.Username, c.Password, c.Ip, c.Port, c.Path)
-	for k, v := range c.Params {
-		buildString += "&" + k + "=" + v[0]
-	}
+	buildString += c.Params.Encode()
 	return buildString
 }
 
@@ -265,7 +263,7 @@ func (c URL) GetMethodParamInt(method string, key string, d int64) int64 {
 
 func (c URL) GetMethodParam(method string, key string, d string) string {
 	var r string
-	if r = c.Params.Get(c.Params.Get("methods." + method + "." + key)); r == "" {
+	if r = c.Params.Get("methods." + method + "." + key); r == "" {
 		r = d
 	}
 	return r

common/url_test.go

+package common
+
+import (
+	"context"
+	"net/url"
+	"testing"
+)
+
+import (
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewURLWithOptions(t *testing.T) {
+	methods := []string{"Methodone,methodtwo"}
+	params := url.Values{}
+	params.Set("key", "value")
+	u := NewURLWithOptions("com.test.Service",
+		WithUsername("username"),
+		WithPassword("password"),
+		WithProtocol("testprotocol"),
+		WithIp("127.0.0.1"),
+		WithPort("8080"),
+		WithMethods(methods),
+		WithParams(params),
+		WithParamsValue("key2", "value2"))
+	assert.Equal(t, "/com.test.Service", u.Path)
+	assert.Equal(t, "username", u.Username)
+	assert.Equal(t, "password", u.Password)
+	assert.Equal(t, "testprotocol", u.Protocol)
+	assert.Equal(t, "127.0.0.1", u.Ip)
+	assert.Equal(t, "8080", u.Port)
+	assert.Equal(t, methods, u.Methods)
+	assert.Equal(t, params, u.Params)
+}
+
+func TestURL(t *testing.T) {
+	u, err := NewURL(context.TODO(), "dubbo://:@127.0.0.1:20000/com.ikurento.user.UserProvider?anyhost=true&"+
+		"application=BDTService&category=providers&default.timeout=10000&dubbo=dubbo-provider-golang-1.0.0&"+
+		"environment=dev&interface=com.ikurento.user.UserProvider&ip=192.168.56.1&methods=GetUser%2C&"+
+		"module=dubbogo+user-info+server&org=ikurento.com&owner=ZX&pid=1447&revision=0.0.1&"+
+		"side=provider&timeout=3000&timestamp=1556509797245")
+	assert.NoError(t, err)
+
+	assert.Equal(t, "/com.ikurento.user.UserProvider", u.Path)
+	assert.Equal(t, "127.0.0.1:20000", u.Location)
+	assert.Equal(t, "dubbo", u.Protocol)
+	assert.Equal(t, "127.0.0.1", u.Ip)
+	assert.Equal(t, "20000", u.Port)
+	assert.Equal(t, URL{}.Methods, u.Methods)
+	assert.Equal(t, "", u.Username)
+	assert.Equal(t, "", u.Password)
+	assert.Equal(t, "anyhost=true&application=BDTService&category=providers&default.timeout=10000&dubbo=dubbo-"+
+		"provider-golang-1.0.0&environment=dev&interface=com.ikurento.user.UserProvider&ip=192.168.56.1&methods=GetUser%"+
+		"2C&module=dubbogo+user-info+server&org=ikurento.com&owner=ZX&pid=1447&revision=0.0.1&side=provider&timeout=3000&t"+
+		"imestamp=1556509797245", u.Params.Encode())
+
+	assert.Equal(t, "dubbo://:@127.0.0.1:20000/com.ikurento.user.UserProvider?anyhost=true&application=BDTServi"+
+		"ce&category=providers&default.timeout=10000&dubbo=dubbo-provider-golang-1.0.0&environment=dev&interface=com.ikure"+
+		"nto.user.UserProvider&ip=192.168.56.1&methods=GetUser%2C&module=dubbogo+user-info+server&org=ikurento.com&owner="+
+		"ZX&pid=1447&revision=0.0.1&side=provider&timeout=3000&timestamp=1556509797245", u.String())
+}
+
+func TestURL_URLEqual(t *testing.T) {
+	u1, err := NewURL(context.TODO(), "dubbo://:@127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=&version=2.6.0")
+	assert.NoError(t, err)
+	u2, err := NewURL(context.TODO(), "dubbo://:@127.0.0.2:20001/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=&version=2.6.0")
+	assert.NoError(t, err)
+	assert.True(t, u1.URLEqual(u2))
+
+	u3, err := NewURL(context.TODO(), "dubbo://:@127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0")
+	assert.NoError(t, err)
+	assert.False(t, u1.URLEqual(u3))
+}
+
+func TestURL_GetParam(t *testing.T) {
+	params := url.Values{}
+	params.Set("key", "value")
+	u := URL{baseUrl: baseUrl{Params: params}}
+	v := u.GetParam("key", "default")
+	assert.Equal(t, "value", v)
+
+	u = URL{}
+	v = u.GetParam("key", "default")
+	assert.Equal(t, "default", v)
+}
+
+func TestURL_GetParamInt(t *testing.T) {
+	params := url.Values{}
+	params.Set("key", "3")
+	u := URL{baseUrl: baseUrl{Params: params}}
+	v := u.GetParamInt("key", 1)
+	assert.Equal(t, int64(3), v)
+
+	u = URL{}
+	v = u.GetParamInt("key", 1)
+	assert.Equal(t, int64(1), v)
+}
+
+func TestURL_GetMethodParamInt(t *testing.T) {
+	params := url.Values{}
+	params.Set("methods.GetValue.timeout", "3")
+	u := URL{baseUrl: baseUrl{Params: params}}
+	v := u.GetMethodParamInt("GetValue", "timeout", 1)
+	assert.Equal(t, int64(3), v)
+
+	u = URL{}
+	v = u.GetMethodParamInt("GetValue", "timeout", 1)
+	assert.Equal(t, int64(1), v)
+}
+
+func TestURL_GetMethodParam(t *testing.T) {
+	params := url.Values{}
+	params.Set("methods.GetValue.timeout", "3s")
+	u := URL{baseUrl: baseUrl{Params: params}}
+	v := u.GetMethodParam("GetValue", "timeout", "1s")
+	assert.Equal(t, "3s", v)
+
+	u = URL{}
+	v = u.GetMethodParam("GetValue", "timeout", "1s")
+	assert.Equal(t, "1s", v)
+}