Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Jackson Tian
|
7f14f961f3 |
@@ -12,8 +12,7 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
strategy:
|
||||
matrix:
|
||||
go: ["1.13", "1.14", "1.15", "1.16", "1.17", "1.18", "1.19", "1.20"]
|
||||
fail-fast: false
|
||||
go: [1.13, 1.14, 1.15]
|
||||
|
||||
steps:
|
||||
- name: Set up Go 1.x
|
||||
|
||||
+2
-1
@@ -2,4 +2,5 @@ coverage.html
|
||||
coverage.txt
|
||||
coverage.out
|
||||
.DS_Store
|
||||
.history/
|
||||
.history/
|
||||
go.sum
|
||||
@@ -1,10 +1,10 @@
|
||||
module github.com/alibabacloud-go/tea/v2
|
||||
module github.com/alibabacloud-go/tea
|
||||
|
||||
go 1.14
|
||||
|
||||
require (
|
||||
github.com/alibabacloud-go/debug v1.0.0
|
||||
github.com/alibabacloud-go/debug v0.0.0-20190504072949-9472017b5c68
|
||||
github.com/json-iterator/go v1.1.12
|
||||
github.com/modern-go/reflect2 v1.0.2
|
||||
golang.org/x/net v0.20.0
|
||||
golang.org/x/net v0.10.0
|
||||
)
|
||||
|
||||
@@ -1,57 +0,0 @@
|
||||
github.com/alibabacloud-go/debug v1.0.0 h1:3eIEQWfay1fB24PQIEzXAswlVJtdQok8f3EVN5VrBnA=
|
||||
github.com/alibabacloud-go/debug v1.0.0/go.mod h1:8gfgZCCAC3+SCzjWtY053FrOcd4/qlH6IHTI4QyICOc=
|
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
|
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
|
||||
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
|
||||
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
|
||||
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
|
||||
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
|
||||
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
|
||||
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
|
||||
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
|
||||
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
|
||||
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
|
||||
golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
|
||||
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
|
||||
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
|
||||
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
|
||||
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
|
||||
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
|
||||
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
|
||||
golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
|
||||
golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
|
||||
golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
|
||||
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
|
||||
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
|
||||
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
|
||||
golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
|
||||
golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
|
||||
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
||||
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
|
||||
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
|
||||
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
|
||||
golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
|
||||
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
|
||||
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
|
||||
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
|
||||
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
|
||||
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
|
||||
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||
@@ -1,117 +0,0 @@
|
||||
package tea
|
||||
|
||||
import (
|
||||
"math"
|
||||
"math/rand"
|
||||
)
|
||||
|
||||
type BackoffPolicy interface {
|
||||
GetDelayTimeMillis(ctx *RetryPolicyContext) *int64
|
||||
}
|
||||
|
||||
func NewBackoffPolicy(options map[string]interface{}) (backoffPolicy BackoffPolicy) {
|
||||
policy := StringValue(TransInterfaceToString(options["policy"]))
|
||||
switch policy {
|
||||
case "Fixed":
|
||||
backoffPolicy = &FixedBackoffPolicy{
|
||||
Period: TransInterfaceToInt(options["period"]),
|
||||
}
|
||||
return
|
||||
case "Random":
|
||||
backoffPolicy = &RandomBackoffPolicy{
|
||||
Period: TransInterfaceToInt(options["period"]),
|
||||
Cap: TransInterfaceToInt64(options["cap"]),
|
||||
}
|
||||
return
|
||||
case "Exponential":
|
||||
backoffPolicy = &ExponentialBackoffPolicy{
|
||||
Period: TransInterfaceToInt(options["period"]),
|
||||
Cap: TransInterfaceToInt64(options["cap"]),
|
||||
}
|
||||
return
|
||||
case "EqualJitter":
|
||||
backoffPolicy = &EqualJitterBackoffPolicy{
|
||||
Period: TransInterfaceToInt(options["period"]),
|
||||
Cap: TransInterfaceToInt64(options["cap"]),
|
||||
}
|
||||
return
|
||||
case "ExponentialWithEqualJitter":
|
||||
backoffPolicy = &EqualJitterBackoffPolicy{
|
||||
Period: TransInterfaceToInt(options["period"]),
|
||||
Cap: TransInterfaceToInt64(options["cap"]),
|
||||
}
|
||||
return
|
||||
case "FullJitter":
|
||||
backoffPolicy = &FullJitterBackoffPolicy{
|
||||
Period: TransInterfaceToInt(options["period"]),
|
||||
Cap: TransInterfaceToInt64(options["cap"]),
|
||||
}
|
||||
return
|
||||
case "ExponentialWithFullJitter":
|
||||
backoffPolicy = &FullJitterBackoffPolicy{
|
||||
Period: TransInterfaceToInt(options["period"]),
|
||||
Cap: TransInterfaceToInt64(options["cap"]),
|
||||
}
|
||||
return
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type FixedBackoffPolicy struct {
|
||||
Period *int
|
||||
}
|
||||
|
||||
func (fixedBackoff *FixedBackoffPolicy) GetDelayTimeMillis(ctx *RetryPolicyContext) *int64 {
|
||||
return Int64(int64(IntValue(fixedBackoff.Period)))
|
||||
}
|
||||
|
||||
type RandomBackoffPolicy struct {
|
||||
Period *int
|
||||
Cap *int64
|
||||
}
|
||||
|
||||
func (randomBackoff *RandomBackoffPolicy) GetDelayTimeMillis(ctx *RetryPolicyContext) *int64 {
|
||||
if randomBackoff.Cap == nil {
|
||||
randomBackoff.Cap = Int64(20 * 1000)
|
||||
}
|
||||
ceil := math.Min(float64(*randomBackoff.Cap), float64(IntValue(randomBackoff.Period))*float64(IntValue(ctx.RetriesAttempted)))
|
||||
return Int64(int64(rand.Float64() * ceil))
|
||||
}
|
||||
|
||||
type ExponentialBackoffPolicy struct {
|
||||
Period *int
|
||||
Cap *int64
|
||||
}
|
||||
|
||||
func (exponentialBackoff *ExponentialBackoffPolicy) GetDelayTimeMillis(ctx *RetryPolicyContext) *int64 {
|
||||
if exponentialBackoff.Cap == nil {
|
||||
exponentialBackoff.Cap = Int64(3 * 24 * 60 * 60 * 1000)
|
||||
}
|
||||
return Int64(int64(math.Min(float64(*exponentialBackoff.Cap), float64(IntValue(exponentialBackoff.Period))*math.Pow(2.0, float64(IntValue(ctx.RetriesAttempted))))))
|
||||
}
|
||||
|
||||
type EqualJitterBackoffPolicy struct {
|
||||
Period *int
|
||||
Cap *int64
|
||||
}
|
||||
|
||||
func (equalJitterBackoff *EqualJitterBackoffPolicy) GetDelayTimeMillis(ctx *RetryPolicyContext) *int64 {
|
||||
if equalJitterBackoff.Cap == nil {
|
||||
equalJitterBackoff.Cap = Int64(3 * 24 * 60 * 60 * 1000)
|
||||
}
|
||||
ceil := math.Min(float64(*equalJitterBackoff.Cap), float64(IntValue(equalJitterBackoff.Period))*math.Pow(2.0, float64(IntValue(ctx.RetriesAttempted))))
|
||||
return Int64(int64(ceil/2 + rand.Float64()*(ceil/2+1)))
|
||||
}
|
||||
|
||||
type FullJitterBackoffPolicy struct {
|
||||
Period *int
|
||||
Cap *int64
|
||||
}
|
||||
|
||||
func (fullJitterBackof *FullJitterBackoffPolicy) GetDelayTimeMillis(ctx *RetryPolicyContext) *int64 {
|
||||
if fullJitterBackof.Cap == nil {
|
||||
fullJitterBackof.Cap = Int64(3 * 24 * 60 * 60 * 1000)
|
||||
}
|
||||
ceil := math.Min(float64(*fullJitterBackof.Cap), float64(IntValue(fullJitterBackof.Period))*math.Pow(2.0, float64(IntValue(ctx.RetriesAttempted))))
|
||||
return Int64(int64(rand.Float64() * ceil))
|
||||
}
|
||||
@@ -1,135 +0,0 @@
|
||||
package tea
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
"github.com/alibabacloud-go/tea/v2/utils"
|
||||
)
|
||||
|
||||
func TestBackoffPolicy(t *testing.T) {
|
||||
var backoffPolicy BackoffPolicy
|
||||
backoffPolicy = NewBackoffPolicy(map[string]interface{}{
|
||||
"policy": "Any",
|
||||
})
|
||||
utils.AssertEqual(t, nil, backoffPolicy)
|
||||
backoffPolicy = NewBackoffPolicy(map[string]interface{}{
|
||||
"policy": "Fixed",
|
||||
"period": 1000,
|
||||
})
|
||||
typeOfPolicy := reflect.TypeOf(backoffPolicy)
|
||||
utils.AssertEqual(t, "FixedBackoffPolicy", typeOfPolicy.Elem().Name())
|
||||
backoffPolicy = NewBackoffPolicy(map[string]interface{}{
|
||||
"policy": "Random",
|
||||
"period": 2,
|
||||
"cap": int64(60 * 1000),
|
||||
})
|
||||
typeOfPolicy = reflect.TypeOf(backoffPolicy)
|
||||
utils.AssertEqual(t, "RandomBackoffPolicy", typeOfPolicy.Elem().Name())
|
||||
backoffPolicy = NewBackoffPolicy(map[string]interface{}{
|
||||
"policy": "Exponential",
|
||||
"period": 2,
|
||||
"cap": int64(60 * 1000),
|
||||
})
|
||||
typeOfPolicy = reflect.TypeOf(backoffPolicy)
|
||||
utils.AssertEqual(t, "ExponentialBackoffPolicy", typeOfPolicy.Elem().Name())
|
||||
backoffPolicy = NewBackoffPolicy(map[string]interface{}{
|
||||
"policy": "EqualJitter",
|
||||
"period": 2,
|
||||
"cap": int64(60 * 1000),
|
||||
})
|
||||
typeOfPolicy = reflect.TypeOf(backoffPolicy)
|
||||
utils.AssertEqual(t, "EqualJitterBackoffPolicy", typeOfPolicy.Elem().Name())
|
||||
backoffPolicy = NewBackoffPolicy(map[string]interface{}{
|
||||
"policy": "ExponentialWithEqualJitter",
|
||||
"period": 2,
|
||||
"cap": int64(60 * 1000),
|
||||
})
|
||||
typeOfPolicy = reflect.TypeOf(backoffPolicy)
|
||||
utils.AssertEqual(t, "EqualJitterBackoffPolicy", typeOfPolicy.Elem().Name())
|
||||
backoffPolicy = NewBackoffPolicy(map[string]interface{}{
|
||||
"policy": "FullJitter",
|
||||
"period": 2,
|
||||
"cap": int64(60 * 1000),
|
||||
})
|
||||
typeOfPolicy = reflect.TypeOf(backoffPolicy)
|
||||
utils.AssertEqual(t, "FullJitterBackoffPolicy", typeOfPolicy.Elem().Name())
|
||||
backoffPolicy = NewBackoffPolicy(map[string]interface{}{
|
||||
"policy": "ExponentialWithFullJitter",
|
||||
"period": 2,
|
||||
"cap": int64(60 * 1000),
|
||||
})
|
||||
typeOfPolicy = reflect.TypeOf(backoffPolicy)
|
||||
utils.AssertEqual(t, "FullJitterBackoffPolicy", typeOfPolicy.Elem().Name())
|
||||
}
|
||||
|
||||
func TestFixedBackoffPolicy(t *testing.T) {
|
||||
backoffPolicy := FixedBackoffPolicy{
|
||||
Period: Int(1000),
|
||||
}
|
||||
utils.AssertEqual(t, int64(1000), Int64Value(backoffPolicy.GetDelayTimeMillis(nil)))
|
||||
retryPolicyContext := RetryPolicyContext{
|
||||
RetriesAttempted: Int(1),
|
||||
}
|
||||
utils.AssertEqual(t, int64(1000), Int64Value(backoffPolicy.GetDelayTimeMillis(&retryPolicyContext)))
|
||||
retryPolicyContext = RetryPolicyContext{
|
||||
RetriesAttempted: Int(2),
|
||||
}
|
||||
utils.AssertEqual(t, int64(1000), Int64Value(backoffPolicy.GetDelayTimeMillis(&retryPolicyContext)))
|
||||
}
|
||||
|
||||
func TestRandomBackoffPolicy(t *testing.T) {
|
||||
backoffPolicy := RandomBackoffPolicy{
|
||||
Period: Int(2),
|
||||
}
|
||||
retryPolicyContext := RetryPolicyContext{
|
||||
RetriesAttempted: Int(1),
|
||||
}
|
||||
utils.AssertEqual(t, true, Int64Value(backoffPolicy.GetDelayTimeMillis(&retryPolicyContext)) < 2)
|
||||
retryPolicyContext = RetryPolicyContext{
|
||||
RetriesAttempted: Int(2),
|
||||
}
|
||||
utils.AssertEqual(t, true, Int64Value(backoffPolicy.GetDelayTimeMillis(&retryPolicyContext)) < 4)
|
||||
}
|
||||
|
||||
func TestExponentialBackoffPolicy(t *testing.T) {
|
||||
backoffPolicy := ExponentialBackoffPolicy{
|
||||
Period: Int(2),
|
||||
}
|
||||
retryPolicyContext := RetryPolicyContext{
|
||||
RetriesAttempted: Int(1),
|
||||
}
|
||||
utils.AssertEqual(t, int64(4), Int64Value(backoffPolicy.GetDelayTimeMillis(&retryPolicyContext)))
|
||||
retryPolicyContext = RetryPolicyContext{
|
||||
RetriesAttempted: Int(2),
|
||||
}
|
||||
utils.AssertEqual(t, int64(8), Int64Value(backoffPolicy.GetDelayTimeMillis(&retryPolicyContext)))
|
||||
}
|
||||
|
||||
func TestEqualJitterBackoffPolicy(t *testing.T) {
|
||||
backoffPolicy := EqualJitterBackoffPolicy{
|
||||
Period: Int(2),
|
||||
}
|
||||
retryPolicyContext := RetryPolicyContext{
|
||||
RetriesAttempted: Int(1),
|
||||
}
|
||||
utils.AssertEqual(t, true, Int64Value(backoffPolicy.GetDelayTimeMillis(&retryPolicyContext)) < 5)
|
||||
retryPolicyContext = RetryPolicyContext{
|
||||
RetriesAttempted: Int(2),
|
||||
}
|
||||
utils.AssertEqual(t, true, Int64Value(backoffPolicy.GetDelayTimeMillis(&retryPolicyContext)) < 9)
|
||||
}
|
||||
|
||||
func TestFullJitterBackoffPolicy(t *testing.T) {
|
||||
backoffPolicy := FullJitterBackoffPolicy{
|
||||
Period: Int(2),
|
||||
}
|
||||
retryPolicyContext := RetryPolicyContext{
|
||||
RetriesAttempted: Int(1),
|
||||
}
|
||||
utils.AssertEqual(t, true, Int64Value(backoffPolicy.GetDelayTimeMillis(&retryPolicyContext)) < 4)
|
||||
retryPolicyContext = RetryPolicyContext{
|
||||
RetriesAttempted: Int(2),
|
||||
}
|
||||
utils.AssertEqual(t, true, Int64Value(backoffPolicy.GetDelayTimeMillis(&retryPolicyContext)) < 8)
|
||||
}
|
||||
-152
@@ -1,152 +0,0 @@
|
||||
package tea
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// BaseError is an interface for getting actual error
|
||||
type BaseError interface {
|
||||
error
|
||||
ErrorName() *string
|
||||
ErrorCode() *string
|
||||
RetryAfterTimeMillis() *int64
|
||||
}
|
||||
|
||||
// CastError is used for cast type fails
|
||||
type CastError struct {
|
||||
Message *string
|
||||
Code *string
|
||||
}
|
||||
|
||||
// NewCastError is used for cast type fails
|
||||
func NewCastError(message *string) *CastError {
|
||||
return &CastError{
|
||||
Message: message,
|
||||
Code: nil,
|
||||
}
|
||||
}
|
||||
|
||||
// Return message of CastError
|
||||
func (err *CastError) Error() string {
|
||||
return StringValue(err.Message)
|
||||
}
|
||||
|
||||
func (err *CastError) ErrorName() *string {
|
||||
return String("CastError")
|
||||
}
|
||||
|
||||
func (err *CastError) ErrorCode() *string {
|
||||
return err.Code
|
||||
}
|
||||
|
||||
func (err *CastError) RetryAfterTimeMillis() *int64 {
|
||||
return nil
|
||||
}
|
||||
|
||||
// SDKError struct is used save error code and message
|
||||
type SDKError struct {
|
||||
Code *string
|
||||
StatusCode *int
|
||||
Message *string
|
||||
Data *string
|
||||
Stack *string
|
||||
errMsg *string
|
||||
Description *string
|
||||
AccessDeniedDetail map[string]interface{}
|
||||
}
|
||||
|
||||
// NewSDKError is used for shortly create SDKError object
|
||||
func NewSDKError(obj map[string]interface{}) *SDKError {
|
||||
err := &SDKError{}
|
||||
if val, ok := obj["code"].(int); ok {
|
||||
err.Code = String(strconv.Itoa(val))
|
||||
} else if val, ok := obj["code"].(string); ok {
|
||||
err.Code = String(val)
|
||||
}
|
||||
|
||||
if obj["message"] != nil {
|
||||
err.Message = String(obj["message"].(string))
|
||||
}
|
||||
if obj["description"] != nil {
|
||||
err.Description = String(obj["description"].(string))
|
||||
}
|
||||
if detail := obj["accessDeniedDetail"]; detail != nil {
|
||||
r := reflect.ValueOf(detail)
|
||||
if r.Kind().String() == "map" {
|
||||
res := make(map[string]interface{})
|
||||
tmp := r.MapKeys()
|
||||
for _, key := range tmp {
|
||||
res[key.String()] = r.MapIndex(key).Interface()
|
||||
}
|
||||
err.AccessDeniedDetail = res
|
||||
}
|
||||
}
|
||||
if data := obj["data"]; data != nil {
|
||||
r := reflect.ValueOf(data)
|
||||
if r.Kind().String() == "map" {
|
||||
res := make(map[string]interface{})
|
||||
tmp := r.MapKeys()
|
||||
for _, key := range tmp {
|
||||
res[key.String()] = r.MapIndex(key).Interface()
|
||||
}
|
||||
if statusCode := res["statusCode"]; statusCode != nil {
|
||||
if code, ok := statusCode.(int); ok {
|
||||
err.StatusCode = Int(code)
|
||||
} else if tmp, ok := statusCode.(string); ok {
|
||||
code, err_ := strconv.Atoi(tmp)
|
||||
if err_ == nil {
|
||||
err.StatusCode = Int(code)
|
||||
}
|
||||
} else if code, ok := statusCode.(*int); ok {
|
||||
err.StatusCode = code
|
||||
}
|
||||
}
|
||||
}
|
||||
byt := bytes.NewBuffer([]byte{})
|
||||
jsonEncoder := json.NewEncoder(byt)
|
||||
jsonEncoder.SetEscapeHTML(false)
|
||||
jsonEncoder.Encode(data)
|
||||
err.Data = String(string(bytes.TrimSpace(byt.Bytes())))
|
||||
}
|
||||
|
||||
if statusCode, ok := obj["statusCode"].(int); ok {
|
||||
err.StatusCode = Int(statusCode)
|
||||
} else if status, ok := obj["statusCode"].(string); ok {
|
||||
statusCode, err_ := strconv.Atoi(status)
|
||||
if err_ == nil {
|
||||
err.StatusCode = Int(statusCode)
|
||||
}
|
||||
}
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
// Set ErrMsg by msg
|
||||
func (err *SDKError) SetErrMsg(msg string) {
|
||||
err.errMsg = String(msg)
|
||||
}
|
||||
|
||||
func (err *SDKError) Error() string {
|
||||
if err.errMsg == nil {
|
||||
str := fmt.Sprintf("SDKError:\n StatusCode: %d\n Code: %s\n Message: %s\n Data: %s\n",
|
||||
IntValue(err.StatusCode), StringValue(err.Code), StringValue(err.Message), StringValue(err.Data))
|
||||
err.SetErrMsg(str)
|
||||
}
|
||||
return StringValue(err.errMsg)
|
||||
}
|
||||
|
||||
func (err *SDKError) ErrorName() *string {
|
||||
return String("SDKError")
|
||||
}
|
||||
|
||||
func (err *SDKError) ErrorCode() *string {
|
||||
return err.Code
|
||||
}
|
||||
|
||||
func (err *SDKError) RetryAfterTimeMillis() *int64 {
|
||||
return nil
|
||||
}
|
||||
@@ -1,115 +0,0 @@
|
||||
package tea
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/alibabacloud-go/tea/v2/utils"
|
||||
)
|
||||
|
||||
func TestCastError(t *testing.T) {
|
||||
var err BaseError
|
||||
err = NewCastError(String("cast error"))
|
||||
utils.AssertEqual(t, "cast error", err.Error())
|
||||
utils.AssertEqual(t, "", StringValue(err.ErrorCode()))
|
||||
utils.AssertEqual(t, "CastError", StringValue(err.ErrorName()))
|
||||
utils.AssertNil(t, err.RetryAfterTimeMillis())
|
||||
}
|
||||
|
||||
func TestSDKError(t *testing.T) {
|
||||
var err0 BaseError
|
||||
err0 = NewSDKError(map[string]interface{}{
|
||||
"code": "code",
|
||||
"statusCode": 404,
|
||||
"message": "message",
|
||||
"data": map[string]interface{}{
|
||||
"httpCode": "404",
|
||||
"requestId": "dfadfa32cgfdcasd4313",
|
||||
"hostId": "github.com/alibabacloud/tea",
|
||||
"recommend": "https://中文?q=a.b&product=c&requestId=123",
|
||||
},
|
||||
"description": "description",
|
||||
"accessDeniedDetail": map[string]interface{}{
|
||||
"AuthAction": "ram:ListUsers",
|
||||
"AuthPrincipalType": "SubUser",
|
||||
"PolicyType": "ResourceGroupLevelIdentityBassdPolicy",
|
||||
"NoPermissionType": "ImplicitDeny",
|
||||
"UserId": 123,
|
||||
},
|
||||
})
|
||||
utils.AssertNotNil(t, err0)
|
||||
utils.AssertEqual(t, "SDKError:\n StatusCode: 404\n Code: code\n Message: message\n Data: {\"hostId\":\"github.com/alibabacloud/tea\",\"httpCode\":\"404\",\"recommend\":\"https://中文?q=a.b&product=c&requestId=123\",\"requestId\":\"dfadfa32cgfdcasd4313\"}\n", err0.Error())
|
||||
var err *SDKError
|
||||
err = err0.(*SDKError)
|
||||
err.SetErrMsg("test")
|
||||
utils.AssertEqual(t, "test", err.Error())
|
||||
utils.AssertEqual(t, 404, *err.StatusCode)
|
||||
utils.AssertEqual(t, "description", *err.Description)
|
||||
utils.AssertEqual(t, "ImplicitDeny", err.AccessDeniedDetail["NoPermissionType"])
|
||||
utils.AssertEqual(t, 123, err.AccessDeniedDetail["UserId"])
|
||||
utils.AssertNil(t, err.RetryAfterTimeMillis())
|
||||
|
||||
err = NewSDKError(map[string]interface{}{
|
||||
"statusCode": "404",
|
||||
"data": map[string]interface{}{
|
||||
"statusCode": 500,
|
||||
},
|
||||
})
|
||||
utils.AssertNotNil(t, err)
|
||||
utils.AssertEqual(t, 404, *err.StatusCode)
|
||||
|
||||
err = NewSDKError(map[string]interface{}{
|
||||
"data": map[string]interface{}{
|
||||
"statusCode": 500,
|
||||
},
|
||||
})
|
||||
utils.AssertNotNil(t, err)
|
||||
utils.AssertEqual(t, 500, *err.StatusCode)
|
||||
|
||||
err = NewSDKError(map[string]interface{}{
|
||||
"data": map[string]interface{}{
|
||||
"statusCode": Int(500),
|
||||
},
|
||||
})
|
||||
utils.AssertNotNil(t, err)
|
||||
utils.AssertEqual(t, 500, *err.StatusCode)
|
||||
|
||||
err = NewSDKError(map[string]interface{}{
|
||||
"data": map[string]interface{}{
|
||||
"statusCode": "500",
|
||||
},
|
||||
})
|
||||
utils.AssertNotNil(t, err)
|
||||
utils.AssertEqual(t, 500, *err.StatusCode)
|
||||
|
||||
err = NewSDKError(map[string]interface{}{
|
||||
"code": "code",
|
||||
"message": "message",
|
||||
"data": map[string]interface{}{
|
||||
"requestId": "dfadfa32cgfdcasd4313",
|
||||
},
|
||||
})
|
||||
utils.AssertNotNil(t, err)
|
||||
utils.AssertNil(t, err.StatusCode)
|
||||
|
||||
err = NewSDKError(map[string]interface{}{
|
||||
"code": 400,
|
||||
"message": "message",
|
||||
"data": "string data",
|
||||
})
|
||||
utils.AssertNotNil(t, err)
|
||||
utils.AssertNotNil(t, err.Data)
|
||||
utils.AssertEqual(t, "400", StringValue(err.Code))
|
||||
utils.AssertNil(t, err.StatusCode)
|
||||
}
|
||||
|
||||
func TestSDKErrorCode404(t *testing.T) {
|
||||
err := NewSDKError(map[string]interface{}{
|
||||
"statusCode": 404,
|
||||
"code": "NOTFOUND",
|
||||
"message": "message",
|
||||
})
|
||||
utils.AssertNotNil(t, err)
|
||||
utils.AssertEqual(t, "SDKError:\n StatusCode: 404\n Code: NOTFOUND\n Message: message\n Data: \n", err.Error())
|
||||
utils.AssertEqual(t, "NOTFOUND", StringValue(err.ErrorCode()))
|
||||
utils.AssertEqual(t, "SDKError", StringValue(err.ErrorName()))
|
||||
}
|
||||
@@ -1,81 +0,0 @@
|
||||
package tea
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
func Prettify(i interface{}) string {
|
||||
resp, _ := json.MarshalIndent(i, "", " ")
|
||||
return string(resp)
|
||||
}
|
||||
|
||||
func Sleep(backoffTime *int64) {
|
||||
sleeptime := time.Duration(Int64Value(backoffTime)) * time.Millisecond
|
||||
time.Sleep(sleeptime)
|
||||
}
|
||||
|
||||
func Merge(args ...interface{}) map[string]*string {
|
||||
finalArg := make(map[string]*string)
|
||||
for _, obj := range args {
|
||||
switch obj.(type) {
|
||||
case map[string]*string:
|
||||
arg := obj.(map[string]*string)
|
||||
for key, value := range arg {
|
||||
if value != nil {
|
||||
finalArg[key] = value
|
||||
}
|
||||
}
|
||||
default:
|
||||
byt, _ := json.Marshal(obj)
|
||||
arg := make(map[string]string)
|
||||
err := json.Unmarshal(byt, &arg)
|
||||
if err != nil {
|
||||
return finalArg
|
||||
}
|
||||
for key, value := range arg {
|
||||
if value != "" {
|
||||
finalArg[key] = String(value)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return finalArg
|
||||
}
|
||||
|
||||
// Convert is use convert map[string]interface object to struct
|
||||
func Convert(in interface{}, out interface{}) error {
|
||||
byt, _ := json.Marshal(in)
|
||||
decoder := jsonParser.NewDecoder(bytes.NewReader(byt))
|
||||
decoder.UseNumber()
|
||||
err := decoder.Decode(&out)
|
||||
return err
|
||||
}
|
||||
|
||||
// Recover is used to format error
|
||||
func Recover(in interface{}) error {
|
||||
if in == nil {
|
||||
return nil
|
||||
}
|
||||
return errors.New(fmt.Sprint(in))
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func Retryable(err error) *bool {
|
||||
if err == nil {
|
||||
return Bool(false)
|
||||
}
|
||||
if realErr, ok := err.(*SDKError); ok {
|
||||
if realErr.StatusCode == nil {
|
||||
return Bool(false)
|
||||
}
|
||||
code := IntValue(realErr.StatusCode)
|
||||
return Bool(code >= http.StatusInternalServerError)
|
||||
}
|
||||
return Bool(true)
|
||||
}
|
||||
@@ -1,132 +0,0 @@
|
||||
package tea
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/alibabacloud-go/tea/v2/utils"
|
||||
)
|
||||
|
||||
type PrettifyTest struct {
|
||||
name string
|
||||
Strs []string
|
||||
Nums8 []int8
|
||||
Unum8 []uint8
|
||||
Value string
|
||||
Mapvalue map[string]string
|
||||
}
|
||||
|
||||
func Test_Prettify(t *testing.T) {
|
||||
prettifyTest := &PrettifyTest{
|
||||
name: "prettify",
|
||||
Nums8: []int8{0, 1, 2, 4},
|
||||
Unum8: []uint8{0},
|
||||
Value: "ok",
|
||||
Mapvalue: map[string]string{"key": "ccp", "value": "ok"},
|
||||
}
|
||||
str := Prettify(prettifyTest)
|
||||
utils.AssertContains(t, str, "Nums8")
|
||||
|
||||
str = Prettify(nil)
|
||||
utils.AssertEqual(t, str, "null")
|
||||
}
|
||||
|
||||
func Test_Sleep(t *testing.T) {
|
||||
start := time.Now()
|
||||
Sleep(Int64(1000))
|
||||
Sleep(Int64(0))
|
||||
Sleep(nil)
|
||||
cost := time.Since(start)
|
||||
utils.AssertEqual(t, cost.Seconds() >= 1, true)
|
||||
}
|
||||
|
||||
func Test_Merge(t *testing.T) {
|
||||
in := map[string]*string{
|
||||
"tea": String("test"),
|
||||
}
|
||||
valid := map[string]interface{}{
|
||||
"valid": "test",
|
||||
}
|
||||
invalidStr := "sdfdg"
|
||||
result := Merge(in, valid, invalidStr)
|
||||
utils.AssertEqual(t, "test", StringValue(result["tea"]))
|
||||
utils.AssertEqual(t, "test", StringValue(result["valid"]))
|
||||
|
||||
result = Merge(nil)
|
||||
utils.AssertEqual(t, map[string]*string{}, result)
|
||||
}
|
||||
|
||||
func Test_Convert(t *testing.T) {
|
||||
in := map[string]interface{}{
|
||||
"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))
|
||||
|
||||
in = map[string]interface{}{
|
||||
"key": 123,
|
||||
"body": []byte("test"),
|
||||
}
|
||||
out = new(test)
|
||||
err = Convert(in, &out)
|
||||
utils.AssertNil(t, err)
|
||||
utils.AssertEqual(t, "123", out.Key)
|
||||
utils.AssertEqual(t, "test", string(out.Body))
|
||||
}
|
||||
|
||||
func Test_Recover(t *testing.T) {
|
||||
err := Recover(nil)
|
||||
utils.AssertNil(t, err)
|
||||
defer func() {
|
||||
if r := Recover(recover()); r != nil {
|
||||
utils.AssertEqual(t, "test", r.Error())
|
||||
}
|
||||
}()
|
||||
panic("test")
|
||||
}
|
||||
|
||||
func Test_Retryable(t *testing.T) {
|
||||
ifRetry := Retryable(nil)
|
||||
utils.AssertEqual(t, false, BoolValue(ifRetry))
|
||||
|
||||
err := errors.New("tea")
|
||||
ifRetry = Retryable(err)
|
||||
utils.AssertEqual(t, true, BoolValue(ifRetry))
|
||||
|
||||
errmsg := map[string]interface{}{
|
||||
"code": "err",
|
||||
}
|
||||
err = NewSDKError(errmsg)
|
||||
ifRetry = Retryable(err)
|
||||
utils.AssertEqual(t, false, BoolValue(ifRetry))
|
||||
|
||||
errmsg["statusCode"] = 400
|
||||
err = NewSDKError(errmsg)
|
||||
ifRetry = Retryable(err)
|
||||
utils.AssertEqual(t, false, BoolValue(ifRetry))
|
||||
|
||||
errmsg["statusCode"] = "400"
|
||||
err = NewSDKError(errmsg)
|
||||
ifRetry = Retryable(err)
|
||||
utils.AssertEqual(t, false, BoolValue(ifRetry))
|
||||
|
||||
errmsg["statusCode"] = 500
|
||||
err = NewSDKError(errmsg)
|
||||
ifRetry = Retryable(err)
|
||||
utils.AssertEqual(t, true, BoolValue(ifRetry))
|
||||
|
||||
errmsg["statusCode"] = "500"
|
||||
err = NewSDKError(errmsg)
|
||||
ifRetry = Retryable(err)
|
||||
utils.AssertEqual(t, true, BoolValue(ifRetry))
|
||||
|
||||
errmsg["statusCode"] = "test"
|
||||
err = NewSDKError(errmsg)
|
||||
ifRetry = Retryable(err)
|
||||
utils.AssertEqual(t, false, BoolValue(ifRetry))
|
||||
}
|
||||
@@ -4,7 +4,7 @@ import (
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
"github.com/alibabacloud-go/tea/v2/utils"
|
||||
"github.com/alibabacloud-go/tea/utils"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
"github.com/modern-go/reflect2"
|
||||
)
|
||||
|
||||
-107
@@ -1,107 +0,0 @@
|
||||
package tea
|
||||
|
||||
import (
|
||||
"math"
|
||||
"time"
|
||||
|
||||
"github.com/alibabacloud-go/tea/v2/utils"
|
||||
)
|
||||
|
||||
const (
|
||||
// DefaultMaxAttempts sets maximum number of retries
|
||||
DefaultMaxAttempts = 3
|
||||
|
||||
// DefaultMinDelay sets minimum retry delay
|
||||
DefaultMinDelay = 100 * time.Millisecond
|
||||
|
||||
// DefaultMaxDelayTimeMillis sets maximum retry delay
|
||||
DefaultMaxDelay = 120 * time.Second
|
||||
)
|
||||
|
||||
type RetryCondition struct {
|
||||
MaxAttempts *int
|
||||
MaxDelayTimeMillis *int64
|
||||
Backoff *BackoffPolicy
|
||||
Exception []*string
|
||||
ErrorCode []*string
|
||||
}
|
||||
|
||||
type RetryOptions struct {
|
||||
Retryable *bool
|
||||
RetryCondition []*RetryCondition
|
||||
NoRetryCondition []*RetryCondition
|
||||
}
|
||||
|
||||
type RetryPolicyContext struct {
|
||||
RetriesAttempted *int
|
||||
Request *Request
|
||||
Response *Response
|
||||
Error error
|
||||
}
|
||||
|
||||
func ShouldRetry(options *RetryOptions, ctx *RetryPolicyContext) *bool {
|
||||
if IntValue(ctx.RetriesAttempted) == 0 {
|
||||
return Bool(true)
|
||||
}
|
||||
if options == nil || !BoolValue(options.Retryable) {
|
||||
return Bool(false)
|
||||
}
|
||||
|
||||
if err, ok := ctx.Error.(BaseError); ok {
|
||||
noRetryConditions := options.NoRetryCondition
|
||||
retryConditions := options.RetryCondition
|
||||
if noRetryConditions != nil {
|
||||
for _, noRetryCondition := range noRetryConditions {
|
||||
if utils.Contains(noRetryCondition.Exception, err.ErrorName()) || utils.Contains(noRetryCondition.ErrorCode, err.ErrorCode()) {
|
||||
return Bool(false)
|
||||
}
|
||||
}
|
||||
}
|
||||
if retryConditions != nil {
|
||||
for _, retryCondition := range retryConditions {
|
||||
if !utils.Contains(retryCondition.Exception, err.ErrorName()) && !utils.Contains(retryCondition.ErrorCode, err.ErrorCode()) {
|
||||
continue
|
||||
}
|
||||
if IntValue(ctx.RetriesAttempted) > IntValue(retryCondition.MaxAttempts) {
|
||||
return Bool(false)
|
||||
}
|
||||
return Bool(true)
|
||||
}
|
||||
}
|
||||
}
|
||||
return Bool(false)
|
||||
}
|
||||
|
||||
func GetBackoffDelay(options *RetryOptions, ctx *RetryPolicyContext) *int64 {
|
||||
if IntValue(ctx.RetriesAttempted) == 0 {
|
||||
return Int64(0)
|
||||
}
|
||||
|
||||
if err, ok := ctx.Error.(BaseError); ok {
|
||||
if options != nil {
|
||||
retryConditions := options.RetryCondition
|
||||
if retryConditions != nil {
|
||||
for _, retryCondition := range retryConditions {
|
||||
if !utils.Contains(retryCondition.Exception, err.ErrorName()) && !utils.Contains(retryCondition.ErrorCode, err.ErrorCode()) {
|
||||
continue
|
||||
}
|
||||
var maxDelay int64
|
||||
if retryCondition.MaxDelayTimeMillis != nil {
|
||||
maxDelay = Int64Value(retryCondition.MaxDelayTimeMillis)
|
||||
} else {
|
||||
maxDelay = DefaultMaxDelay.Milliseconds()
|
||||
}
|
||||
if err.RetryAfterTimeMillis() != nil {
|
||||
return Int64(int64(math.Min(float64(Int64Value(err.RetryAfterTimeMillis())), float64(maxDelay))))
|
||||
}
|
||||
if retryCondition.Backoff == nil {
|
||||
return Int64(DefaultMinDelay.Milliseconds())
|
||||
}
|
||||
delayTimeMillis := (*retryCondition.Backoff).GetDelayTimeMillis(ctx)
|
||||
return Int64(int64(math.Min(float64(Int64Value(delayTimeMillis)), float64(maxDelay))))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return Int64(DefaultMinDelay.Milliseconds())
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
+301
-32
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,12 +1,5 @@
|
||||
package tea
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func String(a string) *string {
|
||||
return &a
|
||||
}
|
||||
@@ -496,71 +489,3 @@ func BoolSliceValue(a []*bool) []bool {
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
func TransInterfaceToBool(val interface{}) *bool {
|
||||
if val == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return Bool(val.(bool))
|
||||
}
|
||||
|
||||
func TransInterfaceToInt(val interface{}) *int {
|
||||
if val == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return Int(val.(int))
|
||||
}
|
||||
|
||||
func TransInterfaceToInt64(val interface{}) *int64 {
|
||||
if val == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return Int64(val.(int64))
|
||||
}
|
||||
|
||||
func TransInterfaceToString(val interface{}) *string {
|
||||
if val == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return String(val.(string))
|
||||
}
|
||||
|
||||
func ToInt(a *int32) *int {
|
||||
return Int(int(Int32Value(a)))
|
||||
}
|
||||
|
||||
func ToInt32(a *int) *int32 {
|
||||
return Int32(int32(IntValue(a)))
|
||||
}
|
||||
|
||||
func ToString(val interface{}) string {
|
||||
return fmt.Sprintf("%v", val)
|
||||
}
|
||||
|
||||
func ToObject(obj interface{}) map[string]interface{} {
|
||||
result := make(map[string]interface{})
|
||||
byt, _ := json.Marshal(obj)
|
||||
err := json.Unmarshal(byt, &result)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func ToReader(obj interface{}) io.Reader {
|
||||
switch obj.(type) {
|
||||
case *string:
|
||||
tmp := obj.(*string)
|
||||
return strings.NewReader(StringValue(tmp))
|
||||
case []byte:
|
||||
return strings.NewReader(string(obj.([]byte)))
|
||||
case io.Reader:
|
||||
return obj.(io.Reader)
|
||||
default:
|
||||
panic("Invalid Body. Please set a valid Body.")
|
||||
}
|
||||
}
|
||||
|
||||
+1
-85
@@ -1,11 +1,9 @@
|
||||
package tea
|
||||
|
||||
import (
|
||||
"io/ioutil"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/alibabacloud-go/tea/v2/utils"
|
||||
"github.com/alibabacloud-go/tea/utils"
|
||||
)
|
||||
|
||||
func Test_Trans(t *testing.T) {
|
||||
@@ -163,85 +161,3 @@ func Test_Trans(t *testing.T) {
|
||||
utils.AssertNil(t, Uint64Slice(nil))
|
||||
utils.AssertNil(t, Uint64ValueSlice(nil))
|
||||
}
|
||||
|
||||
func Test_TransInterfaceToInt(t *testing.T) {
|
||||
a := TransInterfaceToInt(nil)
|
||||
utils.AssertNil(t, a)
|
||||
|
||||
a = TransInterfaceToInt(10)
|
||||
utils.AssertEqual(t, IntValue(a), 10)
|
||||
}
|
||||
|
||||
func Test_TransInterfaceToInt64(t *testing.T) {
|
||||
a := TransInterfaceToInt64(nil)
|
||||
utils.AssertNil(t, a)
|
||||
|
||||
a = TransInterfaceToInt64(int64(10))
|
||||
utils.AssertEqual(t, Int64Value(a), int64(10))
|
||||
}
|
||||
|
||||
func Test_TransInterfaceToString(t *testing.T) {
|
||||
a := TransInterfaceToString(nil)
|
||||
utils.AssertNil(t, a)
|
||||
|
||||
a = TransInterfaceToString("10")
|
||||
utils.AssertEqual(t, StringValue(a), "10")
|
||||
}
|
||||
|
||||
func Test_TransInt32AndInt(t *testing.T) {
|
||||
a := ToInt(Int32(10))
|
||||
utils.AssertEqual(t, IntValue(a), 10)
|
||||
|
||||
b := ToInt32(a)
|
||||
utils.AssertEqual(t, Int32Value(b), int32(10))
|
||||
}
|
||||
|
||||
func Test_ToString(t *testing.T) {
|
||||
str := ToString(10)
|
||||
utils.AssertEqual(t, "10", str)
|
||||
|
||||
str = ToString("10")
|
||||
utils.AssertEqual(t, "10", str)
|
||||
}
|
||||
|
||||
func Test_ToObject(t *testing.T) {
|
||||
str := "{sdsfdsd:"
|
||||
result := ToObject(str)
|
||||
utils.AssertNil(t, result)
|
||||
|
||||
input := map[string]string{
|
||||
"name": "test",
|
||||
}
|
||||
result = ToObject(input)
|
||||
utils.AssertEqual(t, "test", result["name"].(string))
|
||||
}
|
||||
|
||||
func Test_ToReader(t *testing.T) {
|
||||
str := "abc"
|
||||
reader := ToReader(String(str))
|
||||
byt, err := ioutil.ReadAll(reader)
|
||||
utils.AssertNil(t, err)
|
||||
utils.AssertEqual(t, "abc", string(byt))
|
||||
|
||||
read := strings.NewReader("bcd")
|
||||
reader = ToReader(read)
|
||||
byt, err = ioutil.ReadAll(reader)
|
||||
utils.AssertNil(t, err)
|
||||
utils.AssertEqual(t, "bcd", string(byt))
|
||||
|
||||
byts := []byte("cdf")
|
||||
reader = ToReader(byts)
|
||||
byt, err = ioutil.ReadAll(reader)
|
||||
utils.AssertNil(t, err)
|
||||
utils.AssertEqual(t, "cdf", string(byt))
|
||||
|
||||
num := 10
|
||||
defer func() {
|
||||
err := recover()
|
||||
utils.AssertEqual(t, "Invalid Body. Please set a valid Body.", err.(string))
|
||||
}()
|
||||
reader = ToReader(num)
|
||||
byt, err = ioutil.ReadAll(reader)
|
||||
utils.AssertNil(t, err)
|
||||
utils.AssertEqual(t, "", string(byt))
|
||||
}
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
package utils
|
||||
|
||||
func Contains(s []*string, str *string) bool {
|
||||
if s == nil {
|
||||
return false
|
||||
}
|
||||
for _, v := range s {
|
||||
if str != nil && v != nil && *v == *str {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
package utils
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func Test_Contains(t *testing.T) {
|
||||
apple := "apple"
|
||||
banana := "banana"
|
||||
cherry := "cherry"
|
||||
slice := []*string{&apple, &banana, &cherry, nil}
|
||||
AssertEqual(t, true, Contains(slice, &banana))
|
||||
toFind := "banana"
|
||||
AssertEqual(t, true, Contains(slice, &toFind))
|
||||
notFind := "notFind"
|
||||
AssertEqual(t, false, Contains(slice, ¬Find))
|
||||
notFind = ""
|
||||
AssertEqual(t, false, Contains(slice, ¬Find))
|
||||
AssertEqual(t, false, Contains(slice, nil))
|
||||
AssertEqual(t, false, Contains(nil, nil))
|
||||
}
|
||||
Reference in New Issue
Block a user