1 package client
2
3 import (
4 "encoding/json"
5 "net/http"
6 "regexp"
7 "strings"
8 "testing"
9 "time"
10
11 openapiutil "github.com/alibabacloud-go/openapi-util/service"
12 util "github.com/alibabacloud-go/tea-utils/service"
13 "github.com/alibabacloud-go/tea/tea"
14 tea_util "github.com/alibabacloud-go/tea/utils"
15 credential "github.com/aliyun/credentials-go/credentials"
16 )
17
18 type mockHandler struct {
19 content string
20 }
21
22 func (mock *mockHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
23 if req.Header != nil {
24 nv := 0
25 for k, vv := range req.Header {
26 if k != "Content-Length" {
27 nv += len(vv)
28 }
29 }
30 sv := make([]string, nv)
31 for k, vv := range req.Header {
32 if k != "Content-Length" {
33 n := copy(sv, vv)
34 w.Header()[k] = sv[:n:n]
35 sv = sv[n:]
36 }
37 }
38 }
39 w.Header().Set("raw-query", req.URL.RawQuery)
40 body, _ := util.ReadAsString(req.Body)
41 w.Header().Set("raw-body", tea.StringValue(body))
42 w.Header().Set("x-acs-request-id", "A45EE076-334D-5012-9746-A8F828D20FD4")
43 responseBody := "{\"AppId\":\"test\", \"ClassId\":\"test\", \"UserId\":123}"
44 switch mock.content {
45 case "array":
46 responseBody = "[\"AppId\", \"ClassId\", \"UserId\"]"
47 w.WriteHeader(200)
48 w.Write([]byte(responseBody))
49 case "error":
50 responseBody = "{\"Code\":\"error code\", \"Message\":\"error message\", \"RequestId\":\"A45EE076-334D-5012-9746-A8F828D20FD4\"}"
51 w.WriteHeader(400)
52 w.Write([]byte(responseBody))
53 default:
54 w.WriteHeader(200)
55 w.Write([]byte(responseBody))
56 }
57 }
58
59 func TestConfig(t *testing.T) {
60 globalParameters := &GlobalParameters{
61 Headers: map[string]*string{
62 "global-key": tea.String("global-value"),
63 },
64 Queries: map[string]*string{
65 "global-query": tea.String("global-value"),
66 },
67 }
68 config := &Config{
69 Endpoint: tea.String("config.endpoint"),
70 EndpointType: tea.String("public"),
71 Network: tea.String("config.network"),
72 Suffix: tea.String("config.suffix"),
73 Protocol: tea.String("config.protocol"),
74 Method: tea.String("config.method"),
75 RegionId: tea.String("config.regionId"),
76 UserAgent: tea.String("config.userAgent"),
77 ReadTimeout: tea.Int(3000),
78 ConnectTimeout: tea.Int(3000),
79 HttpProxy: tea.String("config.httpProxy"),
80 HttpsProxy: tea.String("config.httpsProxy"),
81 NoProxy: tea.String("config.noProxy"),
82 Socks5Proxy: tea.String("config.socks5Proxy"),
83 Socks5NetWork: tea.String("config.socks5NetWork"),
84 MaxIdleConns: tea.Int(128),
85 SignatureVersion: tea.String("config.signatureVersion"),
86 SignatureAlgorithm: tea.String("config.signatureAlgorithm"),
87 GlobalParameters: globalParameters,
88 }
89 creConfig := &credential.Config{
90 AccessKeyId: tea.String("accessKeyId"),
91 AccessKeySecret: tea.String("accessKeySecret"),
92 SecurityToken: tea.String("securityToken"),
93 Type: tea.String("sts"),
94 }
95 credential, _err := credential.NewCredential(creConfig)
96 tea_util.AssertNil(t, _err)
97
98 config.Credential = credential
99 client, _err := NewClient(config)
100 tea_util.AssertNil(t, _err)
101 ak, _ := client.GetAccessKeyId()
102 tea_util.AssertEqual(t, "accessKeyId", tea.StringValue(ak))
103 sk, _ := client.GetAccessKeySecret()
104 tea_util.AssertEqual(t, "accessKeySecret", tea.StringValue(sk))
105 token, _ := client.GetSecurityToken()
106 tea_util.AssertEqual(t, "securityToken", tea.StringValue(token))
107 ty, _ := client.GetType()
108 tea_util.AssertEqual(t, "sts", tea.StringValue(ty))
109
110 config.AccessKeyId = tea.String("ak")
111 config.AccessKeySecret = tea.String("secret")
112 config.SecurityToken = tea.String("token")
113 config.Type = tea.String("sts")
114 client, _err = NewClient(config)
115 tea_util.AssertNil(t, _err)
116 ak, _ = client.GetAccessKeyId()
117 tea_util.AssertEqual(t, "ak", tea.StringValue(ak))
118 sk, _ = client.GetAccessKeySecret()
119 tea_util.AssertEqual(t, "secret", tea.StringValue(sk))
120 token, _ = client.GetSecurityToken()
121 tea_util.AssertEqual(t, "token", tea.StringValue(token))
122 ty, _ = client.GetType()
123 tea_util.AssertEqual(t, "sts", tea.StringValue(ty))
124 tea_util.AssertNil(t, client.Spi)
125 tea_util.AssertNil(t, client.EndpointRule)
126 tea_util.AssertNil(t, client.EndpointMap)
127 tea_util.AssertNil(t, client.ProductId)
128 tea_util.AssertEqual(t, "config.endpoint", tea.StringValue(client.Endpoint))
129 tea_util.AssertEqual(t, "public", tea.StringValue(client.EndpointType))
130 tea_util.AssertEqual(t, "config.network", tea.StringValue(client.Network))
131 tea_util.AssertEqual(t, "config.suffix", tea.StringValue(client.Suffix))
132 tea_util.AssertEqual(t, "config.protocol", tea.StringValue(client.Protocol))
133 tea_util.AssertEqual(t, "config.method", tea.StringValue(client.Method))
134 tea_util.AssertEqual(t, "config.regionId", tea.StringValue(client.RegionId))
135 tea_util.AssertEqual(t, "config.userAgent", tea.StringValue(client.UserAgent))
136 tea_util.AssertEqual(t, 3000, tea.IntValue(client.ReadTimeout))
137 tea_util.AssertEqual(t, 3000, tea.IntValue(client.ConnectTimeout))
138 tea_util.AssertEqual(t, "config.httpProxy", tea.StringValue(client.HttpProxy))
139 tea_util.AssertEqual(t, "config.httpsProxy", tea.StringValue(client.HttpsProxy))
140 tea_util.AssertEqual(t, "config.noProxy", tea.StringValue(client.NoProxy))
141 tea_util.AssertEqual(t, "config.socks5Proxy", tea.StringValue(client.Socks5Proxy))
142 tea_util.AssertEqual(t, "config.socks5NetWork", tea.StringValue(client.Socks5NetWork))
143 tea_util.AssertEqual(t, 128, tea.IntValue(client.MaxIdleConns))
144 tea_util.AssertEqual(t, "config.signatureVersion", tea.StringValue(client.SignatureVersion))
145 tea_util.AssertEqual(t, "config.signatureAlgorithm", tea.StringValue(client.SignatureAlgorithm))
146 tea_util.AssertEqual(t, "global-value", tea.StringValue(client.GlobalParameters.Headers["global-key"]))
147 tea_util.AssertEqual(t, "global-value", tea.StringValue(client.GlobalParameters.Queries["global-query"]))
148 }
149
150 func CreateConfig() (_result *Config) {
151 globalParameters := &GlobalParameters{
152 Headers: map[string]*string{
153 "global-key": tea.String("global-value"),
154 },
155 Queries: map[string]*string{
156 "global-query": tea.String("global-value"),
157 },
158 }
159 config := &Config{
160 AccessKeyId: tea.String("ak"),
161 AccessKeySecret: tea.String("secret"),
162 SecurityToken: tea.String("token"),
163 Type: tea.String("sts"),
164 UserAgent: tea.String("config.userAgent"),
165 ReadTimeout: tea.Int(3000),
166 ConnectTimeout: tea.Int(3000),
167 MaxIdleConns: tea.Int(128),
168 SignatureVersion: tea.String("config.signatureVersion"),
169 SignatureAlgorithm: tea.String("ACS3-HMAC-SHA256"),
170 GlobalParameters: globalParameters,
171 }
172 _result = config
173 return _result
174 }
175
176 func CreateRuntimeOptions() (_result *util.RuntimeOptions) {
177 runtime := &util.RuntimeOptions{
178 ReadTimeout: tea.Int(4000),
179 ConnectTimeout: tea.Int(4000),
180 MaxIdleConns: tea.Int(100),
181 Autoretry: tea.Bool(true),
182 MaxAttempts: tea.Int(1),
183 BackoffPolicy: tea.String("no"),
184 BackoffPeriod: tea.Int(1),
185 IgnoreSSL: tea.Bool(true),
186 }
187 _result = runtime
188 return _result
189 }
190
191 func CreateOpenApiRequest() (_result *OpenApiRequest) {
192 query := map[string]interface{}{}
193 query["key1"] = tea.String("value")
194 query["key2"] = tea.Int(1)
195 query["key3"] = tea.Bool(true)
196 body := map[string]interface{}{}
197 body["key1"] = tea.String("value")
198 body["key2"] = tea.Int(1)
199 body["key3"] = tea.Bool(true)
200 headers := map[string]*string{
201 "for-test": tea.String("sdk"),
202 }
203 req := &OpenApiRequest{
204 Headers: headers,
205 Query: openapiutil.Query(query),
206 Body: openapiutil.ParseToMap(body),
207 }
208 _result = req
209 return _result
210 }
211
212 func TestCallApiForRPCWithV2Sign_AK_Form(t *testing.T) {
213 mux := http.NewServeMux()
214 mux.Handle("/", &mockHandler{content: "json"})
215 var server *http.Server
216 server = &http.Server{
217 Addr: ":9001",
218 WriteTimeout: time.Second * 4,
219 Handler: mux,
220 }
221 go server.ListenAndServe()
222 config := CreateConfig()
223 runtime := CreateRuntimeOptions()
224 config.Protocol = tea.String("HTTP")
225 config.SignatureAlgorithm = tea.String("v2")
226 config.Endpoint = tea.String("127.0.0.1:9001")
227 client, _err := NewClient(config)
228 tea_util.AssertNil(t, _err)
229 request := CreateOpenApiRequest()
230 params := &Params{
231 Action: tea.String("TestAPI"),
232 Version: tea.String("2022-06-01"),
233 Protocol: tea.String("HTTPS"),
234 Pathname: tea.String("/"),
235 Method: tea.String("POST"),
236 AuthType: tea.String("AK"),
237 Style: tea.String("RPC"),
238 ReqBodyType: tea.String("formData"),
239 BodyType: tea.String("json"),
240 }
241 result, _err := client.CallApi(params, request, runtime)
242 tea_util.AssertNil(t, _err)
243
244 headers := util.AssertAsMap(result["headers"])
245 tea_util.AssertEqual(t, "key1=value&key2=1&key3=true", headers["raw-body"])
246 regx, _ := regexp.Compile("AccessKeyId=ak&Action=TestAPI&Format=json&SecurityToken=token&Signature=.+" +
247 "&SignatureMethod=HMAC-SHA1&SignatureNonce=.+&SignatureVersion=1.0&Timestamp=.+&Version=2022-06-01" +
248 "&key1=value&key2=1&key3=true")
249 find := regx.FindAllString(tea.StringValue(util.AssertAsString(headers["raw-query"])), -1)
250 tea_util.AssertNotNil(t, find)
251 has := strings.Contains(tea.StringValue(util.AssertAsString(headers["user-agent"])), "TeaDSL/1 config.userAgent")
252 tea_util.AssertEqual(t, true, has)
253 tea_util.AssertEqual(t, "2022-06-01", headers["x-acs-version"])
254 tea_util.AssertEqual(t, "TestAPI", headers["x-acs-action"])
255 tea_util.AssertEqual(t, "application/x-www-form-urlencoded", headers["content-type"])
256 tea_util.AssertEqual(t, "A45EE076-334D-5012-9746-A8F828D20FD4", headers["x-acs-request-id"])
257
258 body := util.AssertAsMap(result["body"])
259 tea_util.AssertEqual(t, "test", body["AppId"])
260 tea_util.AssertEqual(t, "test", body["ClassId"])
261 tea_util.AssertEqual(t, "123", body["UserId"].(json.Number).String())
262 }
263
264 func TestCallApiForRPCWithV2Sign_Anonymous_JSON(t *testing.T) {
265 mux := http.NewServeMux()
266 mux.Handle("/", &mockHandler{content: "json"})
267 var server *http.Server
268 server = &http.Server{
269 Addr: ":9002",
270 WriteTimeout: time.Second * 4,
271 Handler: mux,
272 }
273 go server.ListenAndServe()
274 config := CreateConfig()
275 runtime := CreateRuntimeOptions()
276 config.Protocol = tea.String("HTTP")
277 config.SignatureAlgorithm = tea.String("v2")
278 config.Endpoint = tea.String("127.0.0.1:9002")
279 client, _err := NewClient(config)
280 tea_util.AssertNil(t, _err)
281 request := CreateOpenApiRequest()
282 params := &Params{
283 Action: tea.String("TestAPI"),
284 Version: tea.String("2022-06-01"),
285 Protocol: tea.String("HTTPS"),
286 Pathname: tea.String("/"),
287 Method: tea.String("POST"),
288 AuthType: tea.String("Anonymous"),
289 Style: tea.String("RPC"),
290 ReqBodyType: tea.String("json"),
291 BodyType: tea.String("json"),
292 }
293 result, _err := client.CallApi(params, request, runtime)
294 tea_util.AssertNil(t, _err)
295
296 headers := util.AssertAsMap(result["headers"])
297 tea_util.AssertEqual(t, "key1=value&key2=1&key3=true", headers["raw-body"])
298 regx, _ := regexp.Compile("Action=TestAPI&Format=json&SignatureNonce=.+&Timestamp=.+&Version=2022-06-01" +
299 "&key1=value&key2=1&key3=true")
300 find := regx.FindAllString(tea.StringValue(util.AssertAsString(headers["raw-query"])), -1)
301 tea_util.AssertNotNil(t, find)
302 has := strings.Contains(tea.StringValue(util.AssertAsString(headers["user-agent"])), "TeaDSL/1 config.userAgent")
303 tea_util.AssertEqual(t, true, has)
304 tea_util.AssertEqual(t, "2022-06-01", headers["x-acs-version"])
305 tea_util.AssertEqual(t, "TestAPI", headers["x-acs-action"])
306 tea_util.AssertEqual(t, "application/x-www-form-urlencoded", headers["content-type"])
307 tea_util.AssertEqual(t, "A45EE076-334D-5012-9746-A8F828D20FD4", headers["x-acs-request-id"])
308
309 body := util.AssertAsMap(result["body"])
310 tea_util.AssertEqual(t, "test", body["AppId"])
311 tea_util.AssertEqual(t, "test", body["ClassId"])
312 tea_util.AssertEqual(t, "123", body["UserId"].(json.Number).String())
313 }
314
315 func TestCallApiForROAWithV2Sign_HTTPS_AK_Form(t *testing.T) {
316 mux := http.NewServeMux()
317 mux.Handle("/test", &mockHandler{content: "json"})
318 var server *http.Server
319 server = &http.Server{
320 Addr: ":9003",
321 WriteTimeout: time.Second * 4,
322 Handler: mux,
323 }
324 go server.ListenAndServe()
325 config := CreateConfig()
326 runtime := CreateRuntimeOptions()
327 config.Protocol = tea.String("HTTP")
328 config.SignatureAlgorithm = tea.String("v2")
329 config.Endpoint = tea.String("127.0.0.1:9003")
330 client, _err := NewClient(config)
331 tea_util.AssertNil(t, _err)
332 request := CreateOpenApiRequest()
333 params := &Params{
334 Action: tea.String("TestAPI"),
335 Version: tea.String("2022-06-01"),
336 Protocol: tea.String("HTTPS"),
337 Pathname: tea.String("/test"),
338 Method: tea.String("POST"),
339 AuthType: tea.String("AK"),
340 Style: tea.String("ROA"),
341 ReqBodyType: tea.String("formData"),
342 BodyType: tea.String("json"),
343 }
344 result, _err := client.CallApi(params, request, runtime)
345 tea_util.AssertNil(t, _err)
346
347 headers := util.AssertAsMap(result["headers"])
348 tea_util.AssertEqual(t, "key1=value&key2=1&key3=true", headers["raw-body"])
349 tea_util.AssertEqual(t, "key1=value&key2=1&key3=true", headers["raw-query"])
350 has := strings.Contains(tea.StringValue(util.AssertAsString(headers["user-agent"])), "TeaDSL/1 config.userAgent")
351 tea_util.AssertEqual(t, true, has)
352 has = strings.Contains(tea.StringValue(util.AssertAsString(headers["authorization"])), "acs ak:")
353 tea_util.AssertEqual(t, true, has)
354 tea_util.AssertEqual(t, "sdk", headers["for-test"])
355 tea_util.AssertNotNil(t, headers["date"])
356 tea_util.AssertEqual(t, "application/json", headers["accept"])
357 tea_util.AssertNotNil(t, headers["x-acs-signature-nonce"])
358 tea_util.AssertEqual(t, "HMAC-SHA1", headers["x-acs-signature-method"])
359 tea_util.AssertEqual(t, "1.0", headers["x-acs-signature-version"])
360 tea_util.AssertEqual(t, "ak", headers["x-acs-accesskey-id"])
361 tea_util.AssertEqual(t, "token", headers["x-acs-security-token"])
362 tea_util.AssertEqual(t, "2022-06-01", headers["x-acs-version"])
363 tea_util.AssertEqual(t, "TestAPI", headers["x-acs-action"])
364 tea_util.AssertEqual(t, "application/x-www-form-urlencoded", headers["content-type"])
365 tea_util.AssertEqual(t, "A45EE076-334D-5012-9746-A8F828D20FD4", headers["x-acs-request-id"])
366
367 body := util.AssertAsMap(result["body"])
368 tea_util.AssertEqual(t, "test", body["AppId"])
369 tea_util.AssertEqual(t, "test", body["ClassId"])
370 tea_util.AssertEqual(t, "123", body["UserId"].(json.Number).String())
371 }
372
373 func TestCallApiForROAWithV2Sign_Anonymous_JSON(t *testing.T) {
374 mux := http.NewServeMux()
375 mux.Handle("/test", &mockHandler{content: "json"})
376 var server *http.Server
377 server = &http.Server{
378 Addr: ":9004",
379 WriteTimeout: time.Second * 4,
380 Handler: mux,
381 }
382 go server.ListenAndServe()
383 config := CreateConfig()
384 runtime := CreateRuntimeOptions()
385 config.Protocol = tea.String("HTTP")
386 config.SignatureAlgorithm = tea.String("v2")
387 config.Endpoint = tea.String("127.0.0.1:9004")
388 client, _err := NewClient(config)
389 tea_util.AssertNil(t, _err)
390 request := CreateOpenApiRequest()
391 params := &Params{
392 Action: tea.String("TestAPI"),
393 Version: tea.String("2022-06-01"),
394 Protocol: tea.String("HTTPS"),
395 Pathname: tea.String("/test"),
396 Method: tea.String("POST"),
397 AuthType: tea.String("Anonymous"),
398 Style: tea.String("ROA"),
399 ReqBodyType: tea.String("json"),
400 BodyType: tea.String("json"),
401 }
402 result, _err := client.CallApi(params, request, runtime)
403 tea_util.AssertNil(t, _err)
404
405 headers := util.AssertAsMap(result["headers"])
406 tea_util.AssertEqual(t, "{\"key1\":\"value\",\"key2\":1,\"key3\":true}", headers["raw-body"])
407 tea_util.AssertEqual(t, "key1=value&key2=1&key3=true", headers["raw-query"])
408 has := strings.Contains(tea.StringValue(util.AssertAsString(headers["user-agent"])), "TeaDSL/1 config.userAgent")
409 tea_util.AssertEqual(t, true, has)
410 tea_util.AssertEqual(t, "sdk", headers["for-test"])
411 tea_util.AssertNotNil(t, headers["date"])
412 tea_util.AssertEqual(t, "application/json", headers["accept"])
413 tea_util.AssertNotNil(t, headers["x-acs-signature-nonce"])
414 tea_util.AssertEqual(t, "HMAC-SHA1", headers["x-acs-signature-method"])
415 tea_util.AssertEqual(t, "1.0", headers["x-acs-signature-version"])
416 tea_util.AssertEqual(t, "2022-06-01", headers["x-acs-version"])
417 tea_util.AssertEqual(t, "TestAPI", headers["x-acs-action"])
418 tea_util.AssertEqual(t, "application/json; charset=utf-8", headers["content-type"])
419 tea_util.AssertEqual(t, "A45EE076-334D-5012-9746-A8F828D20FD4", headers["x-acs-request-id"])
420
421 body := util.AssertAsMap(result["body"])
422 tea_util.AssertEqual(t, "test", body["AppId"])
423 tea_util.AssertEqual(t, "test", body["ClassId"])
424 tea_util.AssertEqual(t, "123", body["UserId"].(json.Number).String())
425 }
426
427 func TestCallApiForRPCWithV3Sign_AK_Form(t *testing.T) {
428 mux := http.NewServeMux()
429 mux.Handle("/", &mockHandler{content: "json"})
430 var server *http.Server
431 server = &http.Server{
432 Addr: ":9005",
433 WriteTimeout: time.Second * 4,
434 Handler: mux,
435 }
436 go server.ListenAndServe()
437 config := CreateConfig()
438 runtime := CreateRuntimeOptions()
439 config.Protocol = tea.String("HTTP")
440 config.Endpoint = tea.String("127.0.0.1:9005")
441 client, _err := NewClient(config)
442 tea_util.AssertNil(t, _err)
443 request := CreateOpenApiRequest()
444 params := &Params{
445 Action: tea.String("TestAPI"),
446 Version: tea.String("2022-06-01"),
447 Protocol: tea.String("HTTPS"),
448 Pathname: tea.String("/"),
449 Method: tea.String("POST"),
450 AuthType: tea.String("AK"),
451 Style: tea.String("RPC"),
452 ReqBodyType: tea.String("formData"),
453 BodyType: tea.String("json"),
454 }
455 result, _err := client.CallApi(params, request, runtime)
456 tea_util.AssertNil(t, _err)
457
458 headers := util.AssertAsMap(result["headers"])
459 tea_util.AssertEqual(t, "key1=value&key2=1&key3=true", headers["raw-body"])
460 tea_util.AssertEqual(t, "global-query=global-value&key1=value&key2=1&key3=true", headers["raw-query"])
461 has := strings.Contains(tea.StringValue(util.AssertAsString(headers["user-agent"])), "TeaDSL/1 config.userAgent")
462 tea_util.AssertEqual(t, true, has)
463 has = strings.Contains(tea.StringValue(util.AssertAsString(headers["authorization"])), "ACS3-HMAC-SHA256 Credential=ak,"+
464 "SignedHeaders=content-type;host;x-acs-accesskey-id;x-acs-action;x-acs-content-sha256;x-acs-date;x-acs-security-token;"+
465 "x-acs-signature-nonce;x-acs-version,Signature=")
466 tea_util.AssertEqual(t, true, has)
467 tea_util.AssertEqual(t, "sdk", headers["for-test"])
468 tea_util.AssertEqual(t, "global-value", headers["global-key"])
469 tea_util.AssertNotNil(t, headers["x-acs-date"])
470 tea_util.AssertEqual(t, "application/json", headers["accept"])
471 tea_util.AssertNotNil(t, headers["x-acs-signature-nonce"])
472 tea_util.AssertNotNil(t, headers["x-acs-content-sha256"])
473 tea_util.AssertEqual(t, "ak", headers["x-acs-accesskey-id"])
474 tea_util.AssertEqual(t, "token", headers["x-acs-security-token"])
475 tea_util.AssertEqual(t, "2022-06-01", headers["x-acs-version"])
476 tea_util.AssertEqual(t, "TestAPI", headers["x-acs-action"])
477 tea_util.AssertEqual(t, "application/x-www-form-urlencoded", headers["content-type"])
478 tea_util.AssertEqual(t, "A45EE076-334D-5012-9746-A8F828D20FD4", headers["x-acs-request-id"])
479
480 body := util.AssertAsMap(result["body"])
481 tea_util.AssertEqual(t, "test", body["AppId"])
482 tea_util.AssertEqual(t, "test", body["ClassId"])
483 tea_util.AssertEqual(t, "123", body["UserId"].(json.Number).String())
484 }
485
486 func TestCallApiForRPCWithV3Sign_Anonymous_JSON(t *testing.T) {
487 mux := http.NewServeMux()
488 mux.Handle("/", &mockHandler{content: "json"})
489 var server *http.Server
490 server = &http.Server{
491 Addr: ":9006",
492 WriteTimeout: time.Second * 4,
493 Handler: mux,
494 }
495 go server.ListenAndServe()
496 config := CreateConfig()
497 runtime := CreateRuntimeOptions()
498 config.Protocol = tea.String("HTTP")
499 config.Endpoint = tea.String("127.0.0.1:9006")
500 client, _err := NewClient(config)
501 tea_util.AssertNil(t, _err)
502 request := CreateOpenApiRequest()
503 params := &Params{
504 Action: tea.String("TestAPI"),
505 Version: tea.String("2022-06-01"),
506 Protocol: tea.String("HTTPS"),
507 Pathname: tea.String("/"),
508 Method: tea.String("POST"),
509 AuthType: tea.String("Anonymous"),
510 Style: tea.String("RPC"),
511 ReqBodyType: tea.String("json"),
512 BodyType: tea.String("json"),
513 }
514 result, _err := client.CallApi(params, request, runtime)
515 tea_util.AssertNil(t, _err)
516
517 headers := util.AssertAsMap(result["headers"])
518 tea_util.AssertEqual(t, "{\"key1\":\"value\",\"key2\":1,\"key3\":true}", headers["raw-body"])
519 tea_util.AssertEqual(t, "global-query=global-value&key1=value&key2=1&key3=true", headers["raw-query"])
520 has := strings.Contains(tea.StringValue(util.AssertAsString(headers["user-agent"])), "TeaDSL/1 config.userAgent")
521 tea_util.AssertEqual(t, true, has)
522 tea_util.AssertEqual(t, "sdk", headers["for-test"])
523 tea_util.AssertEqual(t, "global-value", headers["global-key"])
524 tea_util.AssertNotNil(t, headers["x-acs-date"])
525 tea_util.AssertEqual(t, "application/json", headers["accept"])
526 tea_util.AssertNotNil(t, headers["x-acs-signature-nonce"])
527 tea_util.AssertNotNil(t, headers["x-acs-content-sha256"])
528 tea_util.AssertEqual(t, "2022-06-01", headers["x-acs-version"])
529 tea_util.AssertEqual(t, "TestAPI", headers["x-acs-action"])
530 tea_util.AssertEqual(t, "application/json; charset=utf-8", headers["content-type"])
531 tea_util.AssertEqual(t, "A45EE076-334D-5012-9746-A8F828D20FD4", headers["x-acs-request-id"])
532
533 body := util.AssertAsMap(result["body"])
534 tea_util.AssertEqual(t, "test", body["AppId"])
535 tea_util.AssertEqual(t, "test", body["ClassId"])
536 tea_util.AssertEqual(t, "123", body["UserId"].(json.Number).String())
537 }
538
539 func TestCallApiForROAWithV3Sign_AK_Form(t *testing.T) {
540 mux := http.NewServeMux()
541 mux.Handle("/test", &mockHandler{content: "json"})
542 var server *http.Server
543 server = &http.Server{
544 Addr: ":9007",
545 WriteTimeout: time.Second * 4,
546 Handler: mux,
547 }
548 go server.ListenAndServe()
549 config := CreateConfig()
550 runtime := CreateRuntimeOptions()
551 config.Protocol = tea.String("HTTP")
552 config.Endpoint = tea.String("127.0.0.1:9007")
553 client, _err := NewClient(config)
554 tea_util.AssertNil(t, _err)
555 request := CreateOpenApiRequest()
556 params := &Params{
557 Action: tea.String("TestAPI"),
558 Version: tea.String("2022-06-01"),
559 Protocol: tea.String("HTTPS"),
560 Pathname: tea.String("/test"),
561 Method: tea.String("POST"),
562 AuthType: tea.String("AK"),
563 Style: tea.String("ROA"),
564 ReqBodyType: tea.String("formData"),
565 BodyType: tea.String("json"),
566 }
567 result, _err := client.CallApi(params, request, runtime)
568 tea_util.AssertNil(t, _err)
569
570 headers := util.AssertAsMap(result["headers"])
571 tea_util.AssertEqual(t, "key1=value&key2=1&key3=true", headers["raw-body"])
572 tea_util.AssertEqual(t, "global-query=global-value&key1=value&key2=1&key3=true", headers["raw-query"])
573 has := strings.Contains(tea.StringValue(util.AssertAsString(headers["user-agent"])), "TeaDSL/1 config.userAgent")
574 tea_util.AssertEqual(t, true, has)
575 has = strings.Contains(tea.StringValue(util.AssertAsString(headers["authorization"])), "ACS3-HMAC-SHA256 Credential=ak,"+
576 "SignedHeaders=content-type;host;x-acs-accesskey-id;x-acs-action;x-acs-content-sha256;x-acs-date;x-acs-security-token;"+
577 "x-acs-signature-nonce;x-acs-version,Signature=")
578 tea_util.AssertEqual(t, true, has)
579 tea_util.AssertEqual(t, "sdk", headers["for-test"])
580 tea_util.AssertEqual(t, "global-value", headers["global-key"])
581 tea_util.AssertNotNil(t, headers["x-acs-date"])
582 tea_util.AssertEqual(t, "application/json", headers["accept"])
583 tea_util.AssertNotNil(t, headers["x-acs-signature-nonce"])
584 tea_util.AssertNotNil(t, headers["x-acs-content-sha256"])
585 tea_util.AssertEqual(t, "ak", headers["x-acs-accesskey-id"])
586 tea_util.AssertEqual(t, "token", headers["x-acs-security-token"])
587 tea_util.AssertEqual(t, "2022-06-01", headers["x-acs-version"])
588 tea_util.AssertEqual(t, "TestAPI", headers["x-acs-action"])
589 tea_util.AssertEqual(t, "application/x-www-form-urlencoded", headers["content-type"])
590 tea_util.AssertEqual(t, "A45EE076-334D-5012-9746-A8F828D20FD4", headers["x-acs-request-id"])
591
592 body := util.AssertAsMap(result["body"])
593 tea_util.AssertEqual(t, "test", body["AppId"])
594 tea_util.AssertEqual(t, "test", body["ClassId"])
595 tea_util.AssertEqual(t, "123", body["UserId"].(json.Number).String())
596 }
597
598 func TestCallApiForROAWithV3Sign_Anonymous_JSON(t *testing.T) {
599 mux := http.NewServeMux()
600 mux.Handle("/test", &mockHandler{content: "json"})
601 var server *http.Server
602 server = &http.Server{
603 Addr: ":9008",
604 WriteTimeout: time.Second * 4,
605 Handler: mux,
606 }
607 go server.ListenAndServe()
608 config := CreateConfig()
609 runtime := CreateRuntimeOptions()
610 config.Protocol = tea.String("HTTP")
611 config.Endpoint = tea.String("127.0.0.1:9008")
612 client, _err := NewClient(config)
613 tea_util.AssertNil(t, _err)
614 request := CreateOpenApiRequest()
615 params := &Params{
616 Action: tea.String("TestAPI"),
617 Version: tea.String("2022-06-01"),
618 Protocol: tea.String("HTTPS"),
619 Pathname: tea.String("/test"),
620 Method: tea.String("POST"),
621 AuthType: tea.String("Anonymous"),
622 Style: tea.String("ROA"),
623 ReqBodyType: tea.String("json"),
624 BodyType: tea.String("json"),
625 }
626 result, _err := client.CallApi(params, request, runtime)
627 tea_util.AssertNil(t, _err)
628
629 headers := util.AssertAsMap(result["headers"])
630 tea_util.AssertEqual(t, "{\"key1\":\"value\",\"key2\":1,\"key3\":true}", headers["raw-body"])
631 tea_util.AssertEqual(t, "global-query=global-value&key1=value&key2=1&key3=true", headers["raw-query"])
632 has := strings.Contains(tea.StringValue(util.AssertAsString(headers["user-agent"])), "TeaDSL/1 config.userAgent")
633 tea_util.AssertEqual(t, true, has)
634 tea_util.AssertEqual(t, "sdk", headers["for-test"])
635 tea_util.AssertEqual(t, "global-value", headers["global-key"])
636 tea_util.AssertNotNil(t, headers["x-acs-date"])
637 tea_util.AssertEqual(t, "application/json", headers["accept"])
638 tea_util.AssertNotNil(t, headers["x-acs-signature-nonce"])
639 tea_util.AssertNotNil(t, headers["x-acs-content-sha256"])
640 tea_util.AssertEqual(t, "2022-06-01", headers["x-acs-version"])
641 tea_util.AssertEqual(t, "TestAPI", headers["x-acs-action"])
642 tea_util.AssertEqual(t, "application/json; charset=utf-8", headers["content-type"])
643 tea_util.AssertEqual(t, "A45EE076-334D-5012-9746-A8F828D20FD4", headers["x-acs-request-id"])
644
645 body := util.AssertAsMap(result["body"])
646 tea_util.AssertEqual(t, "test", body["AppId"])
647 tea_util.AssertEqual(t, "test", body["ClassId"])
648 tea_util.AssertEqual(t, "123", body["UserId"].(json.Number).String())
649 }
650
651 func TestResponseBodyType(t *testing.T) {
652 mux := http.NewServeMux()
653 mux.Handle("/test", &mockHandler{content: "json"})
654 mux.Handle("/testArray", &mockHandler{content: "array"})
655 mux.Handle("/testError", &mockHandler{content: "error"})
656 var server *http.Server
657 server = &http.Server{
658 Addr: ":9009",
659 WriteTimeout: time.Second * 4,
660 Handler: mux,
661 }
662 go server.ListenAndServe()
663 config := CreateConfig()
664 runtime := CreateRuntimeOptions()
665 config.Protocol = tea.String("HTTP")
666 config.Endpoint = tea.String("127.0.0.1:9009")
667 client, _err := NewClient(config)
668 tea_util.AssertNil(t, _err)
669 request := CreateOpenApiRequest()
670 params := &Params{
671 Action: tea.String("TestAPI"),
672 Version: tea.String("2022-06-01"),
673 Protocol: tea.String("HTTPS"),
674 Pathname: tea.String("/test"),
675 Method: tea.String("POST"),
676 AuthType: tea.String("AK"),
677 Style: tea.String("ROA"),
678 ReqBodyType: tea.String("formData"),
679 BodyType: tea.String("json"),
680 }
681 result, _err := client.CallApi(params, request, runtime)
682 tea_util.AssertNil(t, _err)
683 body := util.AssertAsMap(result["body"])
684 tea_util.AssertEqual(t, "test", body["AppId"])
685 tea_util.AssertEqual(t, "test", body["ClassId"])
686 tea_util.AssertEqual(t, "123", body["UserId"].(json.Number).String())
687
688 params.BodyType = tea.String("array")
689 params.Pathname = tea.String("/testArray")
690 result, _err = client.CallApi(params, request, runtime)
691 tea_util.AssertNil(t, _err)
692 bodyArray := util.AssertAsArray(result["body"])
693 tea_util.AssertEqual(t, "AppId", bodyArray[0])
694 tea_util.AssertEqual(t, "ClassId", bodyArray[1])
695 tea_util.AssertEqual(t, "UserId", bodyArray[2])
696
697 params.BodyType = tea.String("string")
698 params.Pathname = tea.String("/test")
699 result, _err = client.CallApi(params, request, runtime)
700 tea_util.AssertNil(t, _err)
701 bodyStr := util.AssertAsString(result["body"])
702 tea_util.AssertEqual(t, "{\"AppId\":\"test\", \"ClassId\":\"test\", \"UserId\":123}", tea.StringValue(bodyStr))
703
704 params.Pathname = tea.String("/testError")
705 tryErr := func() (_e error) {
706 defer func() {
707 if r := tea.Recover(recover()); r != nil {
708 _e = r
709 }
710 }()
711 _, _err = client.CallApi(params, request, runtime)
712 if _err != nil {
713 return _err
714 }
715 return nil
716 }()
717
718 tea_util.AssertNotNil(t, tryErr)
719 error := tryErr.(*tea.SDKError)
720 tea_util.AssertEqual(t, "code: 400, error message request id: A45EE076-334D-5012-9746-A8F828D20FD4", tea.StringValue(error.Message))
721 }
722
View as plain text