supoort MapValuePointer

tea/tea_test.go

@@ -78,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())
 }
 
@@ -123,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) {
@@ -165,42 +165,42 @@ func TestToObject(t *testing.T) {
 }
 
 func TestAllowRetry(t *testing.T) {
-	allow := AllowRetry(nil, 0)
-	utils.AssertEqual(t, true, allow)
+	allow := AllowRetry(nil, Int(0))
+	utils.AssertEqual(t, true, BoolValue(allow))
 
-	allow = AllowRetry(nil, 1)
-	utils.AssertEqual(t, false, allow)
+	allow = AllowRetry(nil, Int(1))
+	utils.AssertEqual(t, false, BoolValue(allow))
 
 	input := map[string]interface{}{
 		"retryable":   false,
 		"maxAttempts": 2,
 	}
-	allow = AllowRetry(input, 1)
-	utils.AssertEqual(t, false, allow)
+	allow = AllowRetry(input, Int(1))
+	utils.AssertEqual(t, false, BoolValue(allow))
 
 	input["retryable"] = true
-	allow = AllowRetry(input, 3)
-	utils.AssertEqual(t, false, allow)
+	allow = AllowRetry(input, Int(3))
+	utils.AssertEqual(t, false, BoolValue(allow))
 
 	input["retryable"] = true
-	allow = AllowRetry(input, 1)
-	utils.AssertEqual(t, true, allow)
+	allow = AllowRetry(input, Int(1))
+	utils.AssertEqual(t, true, BoolValue(allow))
 }
 
 func TestMerge(t *testing.T) {
-	in := map[string]string{
-		"tea": "test",
+	in := map[string]*string{
+		"tea": String("test"),
 	}
 	valid := map[string]interface{}{
 		"valid": "test",
 	}
 	invalidStr := "sdfdg"
 	result := Merge(in, valid, invalidStr)
-	utils.AssertEqual(t, "test", result["tea"])
-	utils.AssertEqual(t, "test", result["valid"])
+	utils.AssertEqual(t, "test", StringValue(result["tea"]))
+	utils.AssertEqual(t, "test", StringValue(result["valid"]))
 
 	result = Merge(nil)
-	utils.AssertEqual(t, map[string]string{}, result)
+	utils.AssertEqual(t, map[string]*string{}, result)
 }
 
 type Test struct {
@@ -213,8 +213,8 @@ type Test struct {
 }
 
 func TestToMap(t *testing.T) {
-	in := map[string]string{
-		"tea": "test",
+	in := map[string]*string{
+		"tea": String("test"),
 	}
 	result := ToMap(in)
 	utils.AssertEqual(t, "test", result["tea"])
@@ -228,19 +228,19 @@ func TestToMap(t *testing.T) {
 	valid := &Test{
 		Msg: String("tea"),
 		Cast: &CastError{
-			Message: "message",
+			Message: String("message"),
 		},
 		ListPtr: StringSlice([]string{"test", ""}),
 		List:    []string{"list"},
 		CastListPtr: []*CastError{
 			&CastError{
-				Message: "CastListPtr",
+				Message: String("CastListPtr"),
 			},
 			nil,
 		},
 		CastList: []CastError{
 			CastError{
-				Message: "CastList",
+				Message: String("CastList"),
 			},
 		},
 	}
@@ -258,18 +258,18 @@ func TestToMap(t *testing.T) {
 	result = ToMap(valid1)
 	utils.AssertEqual(t, "tea", result["Msg"])
 
-	validStr := `{"test":"ok"}`
+	validStr := String(`{"test":"ok"}`)
 	result = ToMap(validStr)
 	utils.AssertEqual(t, "ok", result["test"])
 
-	validStr1 := `{"test":"ok","num":1}`
+	validStr1 := String(`{"test":"ok","num":1}`)
 	result = ToMap(validStr1)
 	utils.AssertEqual(t, "ok", result["test"])
 
-	result = ToMap([]byte(validStr))
+	result = ToMap([]byte(StringValue(validStr)))
 	utils.AssertEqual(t, "ok", result["test"])
 
-	result = ToMap([]byte(validStr1))
+	result = ToMap([]byte(StringValue(validStr1)))
 	utils.AssertEqual(t, "ok", result["test"])
 
 	invalidStr := "sdfdg"
@@ -285,45 +285,45 @@ func TestToMap(t *testing.T) {
 
 func Test_Retryable(t *testing.T) {
 	ifRetry := Retryable(nil)
-	utils.AssertEqual(t, false, ifRetry)
+	utils.AssertEqual(t, false, BoolValue(ifRetry))
 
 	err := errors.New("tea")
 	ifRetry = Retryable(err)
-	utils.AssertEqual(t, true, ifRetry)
+	utils.AssertEqual(t, true, BoolValue(ifRetry))
 
 	errmsg := map[string]interface{}{
 		"code": "err",
 	}
 	err = NewSDKError(errmsg)
 	ifRetry = Retryable(err)
-	utils.AssertEqual(t, true, ifRetry)
+	utils.AssertEqual(t, true, BoolValue(ifRetry))
 
 	errmsg["code"] = "400"
 	err = NewSDKError(errmsg)
 	ifRetry = Retryable(err)
-	utils.AssertEqual(t, false, ifRetry)
+	utils.AssertEqual(t, false, BoolValue(ifRetry))
 }
 
 func Test_GetBackoffTime(t *testing.T) {
-	ms := GetBackoffTime(nil, 0)
-	utils.AssertEqual(t, 0, ms)
+	ms := GetBackoffTime(nil, Int(0))
+	utils.AssertEqual(t, 0, IntValue(ms))
 
 	backoff := map[string]interface{}{
 		"policy": "no",
 	}
-	ms = GetBackoffTime(backoff, 0)
-	utils.AssertEqual(t, 0, ms)
+	ms = GetBackoffTime(backoff, Int(0))
+	utils.AssertEqual(t, 0, IntValue(ms))
 
 	backoff["policy"] = "yes"
 	backoff["period"] = 0
-	ms = GetBackoffTime(backoff, 1)
-	utils.AssertEqual(t, 0, ms)
+	ms = GetBackoffTime(backoff, Int(1))
+	utils.AssertEqual(t, 0, IntValue(ms))
 
-	Sleep(1)
+	Sleep(Int(1))
 
 	backoff["period"] = 3
-	ms = GetBackoffTime(backoff, 1)
-	utils.AssertEqual(t, true, ms <= 3)
+	ms = GetBackoffTime(backoff, Int(1))
+	utils.AssertEqual(t, true, IntValue(ms) <= 3)
 }
 
 func Test_DoRequest(t *testing.T) {
@@ -343,8 +343,8 @@ func Test_DoRequest(t *testing.T) {
 
 	request.Method = String("")
 	request.Protocol = String("https")
-	request.Query = map[string]string{
-		"tea": "test",
+	request.Query = map[string]*string{
+		"tea": String("test"),
 	}
 	runtimeObj["httpsProxy"] = "# #%gfdf"
 	resp, err = DoRequest(request, runtimeObj)
@@ -352,13 +352,13 @@ func Test_DoRequest(t *testing.T) {
 	utils.AssertEqual(t, `parse # #%gfdf: invalid URL escape "%gf"`, err.Error())
 
 	request.Pathname = String("?log")
-	request.Headers["tea"] = ""
+	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"] = "tea-cn-hangzhou.aliyuncs.com:80"
+	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())
@@ -377,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) {
@@ -427,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)
@@ -446,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)
@@ -473,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())
@@ -491,7 +491,7 @@ func Test_hookdo(t *testing.T) {
 
 func Test_ToReader(t *testing.T) {
 	str := "abc"
-	reader := ToReader(str)
+	reader := ToReader(String(str))
 	byt, err := ioutil.ReadAll(reader)
 	utils.AssertNil(t, err)
 	utils.AssertEqual(t, "abc", string(byt))