modify map value type

tea/tea_test.go

@@ -18,7 +18,8 @@ import (
 )
 
 type test struct {
-	Key string `json:"key"`
+	Key  string `json:"key"`
+	Body []byte `json:"body"`
 }
 
 type PrettifyTest struct {
@@ -46,6 +47,7 @@ var runtimeObj = map[string]interface{}{
 
 type validateTest struct {
 	Num  *int       `json:"num" require:"true"`
+	Name *string    `json:"name" maxLength:"4"`
 	Str  *string    `json:"str" pattern:"^[a-d]*$" maxLength:"4"`
 	Test *errLength `json:"test"`
 	List []*string  `json:"list" pattern:"^[a-d]*$" maxLength:"4"`
@@ -76,7 +78,7 @@ func mockResponse(statusCode int, content string, mockerr error) (res *http.Resp
 }
 
 func TestCastError(t *testing.T) {
-	err := NewCastError("cast error")
+	err := NewCastError(String("cast error"))
 	utils.AssertEqual(t, "cast error", err.Error())
 }
 
@@ -99,12 +101,14 @@ func TestResponse(t *testing.T) {
 
 func TestConvert(t *testing.T) {
 	in := map[string]interface{}{
-		"key": "value",
+		"key":  "value",
+		"body": []byte("test"),
 	}
 	out := new(test)
 	err := Convert(in, &out)
 	utils.AssertNil(t, err)
 	utils.AssertEqual(t, "value", out.Key)
+	utils.AssertEqual(t, "test", string(out.Body))
 }
 
 func TestConvertType(t *testing.T) {
@@ -119,10 +123,10 @@ func TestConvertType(t *testing.T) {
 
 func TestRuntimeObject(t *testing.T) {
 	runtimeobject := NewRuntimeObject(nil)
-	utils.AssertEqual(t, runtimeobject.IgnoreSSL, false)
+	utils.AssertNil(t, runtimeobject.IgnoreSSL)
 
 	runtimeobject = NewRuntimeObject(runtimeObj)
-	utils.AssertEqual(t, false, runtimeobject.IgnoreSSL)
+	utils.AssertEqual(t, false, BoolValue(runtimeobject.IgnoreSSL))
 }
 
 func TestSDKError(t *testing.T) {
@@ -136,7 +140,7 @@ func TestSDKError(t *testing.T) {
 		},
 	})
 	utils.AssertNotNil(t, err)
-	utils.AssertEqual(t, "SDKError: code message {\"hostId\":\"github.com/alibabacloud/tea\",\"httpCode\":\"404\",\"requestId\":\"dfadfa32cgfdcasd4313\"}", err.Error())
+	utils.AssertEqual(t, "SDKError:\n   Code: code\n   Message: message\n   Data: {\"hostId\":\"github.com/alibabacloud/tea\",\"httpCode\":\"404\",\"requestId\":\"dfadfa32cgfdcasd4313\"}\n", err.Error())
 }
 
 func TestSDKErrorCode404(t *testing.T) {
@@ -145,7 +149,7 @@ func TestSDKErrorCode404(t *testing.T) {
 		"message": "message",
 	})
 	utils.AssertNotNil(t, err)
-	utils.AssertEqual(t, "SDKError: 404 message ", err.Error())
+	utils.AssertEqual(t, "SDKError:\n   Code: 404\n   Message: message\n   Data: \n", err.Error())
 }
 
 func TestToObject(t *testing.T) {
@@ -200,51 +204,83 @@ func TestMerge(t *testing.T) {
 }
 
 type Test struct {
-	Msg         *string
-	Cast        *CastError
-	ListPtr     []*string
-	List        []string
-	CastList    []CastError
-	CastListPtr []*CastError
+	Msg         *string      `json:"Msg"`
+	Cast        *CastError   `json:"Cast"`
+	ListPtr     []*string    `json:"ListPtr"`
+	List        []string     `json:"List"`
+	CastList    []CastError  `json:"CastList"`
+	CastListPtr []*CastError `json:"CastListPtr"`
 }
 
 func TestToMap(t *testing.T) {
 	in := map[string]string{
 		"tea": "test",
 	}
+	result := ToMap(in)
+	utils.AssertEqual(t, "test", result["tea"])
+
 	validMap := map[string]interface{}{
 		"valid": "test",
 	}
+	result = ToMap(validMap)
+	utils.AssertEqual(t, "test", result["valid"])
+
 	valid := &Test{
 		Msg: String("tea"),
 		Cast: &CastError{
-			Message: "message",
+			Message: String("message"),
 		},
-		ListPtr: StringSlice([]string{"test"}),
+		ListPtr: StringSlice([]string{"test", ""}),
 		List:    []string{"list"},
 		CastListPtr: []*CastError{
 			&CastError{
-				Message: "message",
+				Message: String("CastListPtr"),
 			},
+			nil,
 		},
 		CastList: []CastError{
 			CastError{
-				Message: "message",
+				Message: String("CastList"),
 			},
 		},
 	}
+	result = ToMap(valid)
+	utils.AssertEqual(t, "tea", result["Msg"])
+	utils.AssertEqual(t, map[string]interface{}{"Message": "message"}, result["Cast"])
+	utils.AssertEqual(t, []interface{}{"test", ""}, result["ListPtr"])
+	utils.AssertEqual(t, []interface{}{"list"}, result["List"])
+	utils.AssertEqual(t, []interface{}{map[string]interface{}{"Message": "CastListPtr"}}, result["CastListPtr"])
+	utils.AssertEqual(t, []interface{}{map[string]interface{}{"Message": "CastList"}}, result["CastList"])
+
 	valid1 := &Test{
 		Msg: String("tea"),
 	}
+	result = ToMap(valid1)
+	utils.AssertEqual(t, "tea", result["Msg"])
+
 	validStr := `{"test":"ok"}`
+	result = ToMap(validStr)
+	utils.AssertEqual(t, "ok", result["test"])
+
 	validStr1 := `{"test":"ok","num":1}`
+	result = ToMap(validStr1)
+	utils.AssertEqual(t, "ok", result["test"])
+
+	result = ToMap([]byte(validStr))
+	utils.AssertEqual(t, "ok", result["test"])
+
+	result = ToMap([]byte(validStr1))
+	utils.AssertEqual(t, "ok", result["test"])
+
 	invalidStr := "sdfdg"
-	result := ToMap(in, validMap, valid, valid1, validStr, validStr1, []byte(validStr), []byte(validStr1), invalidStr, 10)
-	utils.AssertEqual(t, "test", result["tea"])
-	utils.AssertEqual(t, "test", result["valid"])
+	result = ToMap(invalidStr)
+	utils.AssertEqual(t, map[string]interface{}{}, result)
+
+	result = ToMap(10)
+	utils.AssertEqual(t, map[string]interface{}{}, result)
 
 	result = ToMap(nil)
-	utils.AssertEqual(t, map[string]interface{}{}, result)
+	utils.AssertNil(t, result)
 }
 
 func Test_Retryable(t *testing.T) {
@@ -299,29 +335,34 @@ func Test_DoRequest(t *testing.T) {
 		}
 	}
 	request := NewRequest()
-	request.Port = 80
-	request.Method = "TEA TEST"
+	request.Port = Int(80)
+	request.Method = String("TEA TEST")
 	resp, err := DoRequest(request, nil)
 	utils.AssertNil(t, resp)
 	utils.AssertEqual(t, `net/http: invalid method "TEA TEST"`, err.Error())
 
-	request.Method = ""
-	request.Protocol = "https"
-	request.Query = map[string]string{
-		"tea": "test",
+	request.Method = String("")
+	request.Protocol = String("https")
+	request.Query = map[string]*string{
+		"tea": String("test"),
 	}
 	runtimeObj["httpsProxy"] = "# #%gfdf"
 	resp, err = DoRequest(request, runtimeObj)
 	utils.AssertNil(t, resp)
 	utils.AssertEqual(t, `parse # #%gfdf: invalid URL escape "%gf"`, err.Error())
 
-	request.Pathname = "?log"
-	request.Headers["tea"] = ""
+	request.Pathname = String("?log")
+	request.Headers["tea"] = String("")
 	runtimeObj["httpsProxy"] = "http://someuser:somepassword@ecs.aliyun.com"
 	resp, err = DoRequest(request, runtimeObj)
 	utils.AssertNil(t, resp)
 	utils.AssertEqual(t, `Internal error`, err.Error())
 
+	request.Headers["host"] = String("tea-cn-hangzhou.aliyuncs.com:80")
+	resp, err = DoRequest(request, runtimeObj)
+	utils.AssertNil(t, resp)
+	utils.AssertEqual(t, `Internal error`, err.Error())
+
 	runtimeObj["socks5Proxy"] = "# #%gfdf"
 	resp, err = DoRequest(request, runtimeObj)
 	utils.AssertNil(t, resp)
@@ -336,7 +377,7 @@ func Test_DoRequest(t *testing.T) {
 	runtimeObj["localAddr"] = "127.0.0.1"
 	resp, err = DoRequest(request, runtimeObj)
 	utils.AssertNil(t, err)
-	utils.AssertEqual(t, "test", resp.Headers["tea"])
+	utils.AssertEqual(t, "test", StringValue(resp.Headers["tea"]))
 }
 
 func Test_DoRequestWithConcurrent(t *testing.T) {
@@ -386,13 +427,13 @@ func Test_getHttpProxy(t *testing.T) {
 		os.Setenv("no_proxy", originnoproxy)
 	}()
 	runtime := &RuntimeObject{
-		NoProxy: "www.aliyun.com",
+		NoProxy: String("www.aliyun.com"),
 	}
 	proxy, err := getHttpProxy("http", "www.aliyun.com", runtime)
 	utils.AssertNil(t, proxy)
 	utils.AssertNil(t, err)
 
-	runtime.NoProxy = ""
+	runtime.NoProxy = nil
 	os.Setenv("no_proxy", "tea")
 	os.Setenv("http_proxy", "tea.aliyun.com")
 	proxy, err = getHttpProxy("http", "www.aliyun.com", runtime)
@@ -405,7 +446,7 @@ func Test_getHttpProxy(t *testing.T) {
 	utils.AssertEqual(t, "tea1.aliyun.com", proxy.Path)
 	utils.AssertNil(t, err)
 
-	runtime.HttpProxy = "tea2.aliyun.com"
+	runtime.HttpProxy = String("tea2.aliyun.com")
 	proxy, err = getHttpProxy("http", "www.aliyun.com", runtime)
 	utils.AssertEqual(t, "tea2.aliyun.com", proxy.Path)
 	utils.AssertNil(t, err)
@@ -432,7 +473,7 @@ func Test_SetDialContext(t *testing.T) {
 	utils.AssertNil(t, c)
 	utils.AssertEqual(t, "dial 127.0.0.1: unknown network 127.0.0.1", err.Error())
 
-	runtime.LocalAddr = "127.0.0.1"
+	runtime.LocalAddr = String("127.0.0.1")
 	c, err = dialcontext(ctx, "127.0.0.1", "127.0.0.2")
 	utils.AssertNil(t, c)
 	utils.AssertEqual(t, "dial 127.0.0.1: unknown network 127.0.0.1", err.Error())
@@ -501,7 +542,7 @@ func Test_validate(t *testing.T) {
 	utils.AssertNil(t, err)
 
 	num := 1
-	str0, str1 := "acc", "abcddd"
+	str0, str1 := "abc", "abcddd"
 	val := &validateTest{
 		Num:  &num,
 		Str:  &str0,
@@ -519,6 +560,10 @@ func Test_validate(t *testing.T) {
 	err = validate(reflect.ValueOf(val))
 	utils.AssertEqual(t, "num should be setted", err.Error())
 
+	val.Name = String("最大长度")
+	err = validate(reflect.ValueOf(val))
+	utils.AssertEqual(t, "num should be setted", err.Error())
+
 	val.Num = &num
 	val.Str = &str0
 	val.List = []*string{&str1}