1/* 2 * Licensed under the Apache License, Version 2.0 (the "License"); 3 * you may not use this file except in compliance with the License. 4 * You may obtain a copy of the License at 5 * 6 * http://www.apache.org/licenses/LICENSE-2.0 7 * 8 * Unless required by applicable law or agreed to in writing, software 9 * distributed under the License is distributed on an "AS IS" BASIS, 10 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 * See the License for the specific language governing permissions and 12 * limitations under the License. 13 */ 14 15package sdk 16 17import ( 18 "bytes" 19 "fmt" 20 "io/ioutil" 21 "net/http" 22 "net/http/httptest" 23 "os" 24 "strconv" 25 "strings" 26 "testing" 27 "time" 28 29 "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider" 30 31 "github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses" 32 33 "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials" 34 "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests" 35 36 "github.com/stretchr/testify/assert" 37) 38 39type signertest struct { 40 name string 41} 42 43func (s *signertest) GetName() string { 44 return "" 45} 46 47func (s *signertest) GetType() string { 48 return "" 49} 50 51func (s *signertest) GetVersion() string { 52 return "" 53} 54 55func (s *signertest) GetAccessKeyId() (string, error) { 56 return "", nil 57} 58 59func (s *signertest) GetExtraParam() map[string]string { 60 return nil 61} 62 63func (s *signertest) Sign(stringToSign, secretSuffix string) string { 64 return "" 65} 66 67func Test_Client(t *testing.T) { 68 defer func() { 69 err := recover() 70 assert.NotNil(t, err) 71 assert.Equal(t, "not support yet", err) 72 }() 73 NewClient() 74} 75 76func Test_NewClientWithOptions(t *testing.T) { 77 c := NewConfig() 78 c.HttpTransport = &http.Transport{ 79 IdleConnTimeout: time.Duration(10 * time.Second), 80 } 81 c.EnableAsync = true 82 c.GoRoutinePoolSize = 1 83 c.MaxTaskQueueSize = 1 84 credential := credentials.NewAccessKeyCredential("acesskeyid", "accesskeysecret") 85 client, err := NewClientWithOptions("regionid", c, credential) 86 assert.Nil(t, err) 87 assert.NotNil(t, client) 88} 89 90func Test_NewClientWithPolicy(t *testing.T) { 91 client, err := NewClientWithRamRoleArnAndPolicy("regionid", "acesskeyid", "accesskeysecret", "roleArn", "sessionName", "policy") 92 assert.Nil(t, err) 93 assert.NotNil(t, client) 94} 95 96func Test_NewClientWithAccessKey(t *testing.T) { 97 client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") 98 assert.Nil(t, err) 99 assert.NotNil(t, client) 100} 101 102func Test_NewClientWithStsToken(t *testing.T) { 103 client, err := NewClientWithStsToken("regionid", "acesskeyid", "accesskeysecret", "token") 104 assert.Nil(t, err) 105 assert.NotNil(t, client) 106} 107 108func Test_NewClientWithRamRoleArn(t *testing.T) { 109 client, err := NewClientWithRamRoleArn("regionid", "acesskeyid", "accesskeysecret", "roleArn", "roleSessionName") 110 assert.Nil(t, err) 111 assert.NotNil(t, client) 112 config := client.InitClientConfig() 113 assert.NotNil(t, config) 114} 115 116func Test_NewClientWithEcsRamRole(t *testing.T) { 117 client, err := NewClientWithEcsRamRole("regionid", "roleName") 118 assert.Nil(t, err) 119 assert.NotNil(t, client) 120} 121 122func Test_NewClientWithRsaKeyPair(t *testing.T) { 123 client, err := NewClientWithRsaKeyPair("regionid", "publicKey", "privateKey", 3600) 124 assert.Nil(t, err) 125 assert.NotNil(t, client) 126} 127 128func mockResponse(statusCode int, content string, mockerr error) (res *http.Response, err error) { 129 status := strconv.Itoa(statusCode) 130 res = &http.Response{ 131 Proto: "HTTP/1.1", 132 ProtoMajor: 1, 133 Header: make(http.Header), 134 StatusCode: statusCode, 135 Status: status + " " + http.StatusText(statusCode), 136 } 137 res.Body = ioutil.NopCloser(bytes.NewReader([]byte(content))) 138 err = mockerr 139 return 140} 141 142func Test_DoActionWithProxy(t *testing.T) { 143 client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") 144 assert.Nil(t, err) 145 assert.NotNil(t, client) 146 assert.Equal(t, true, client.isRunning) 147 request := requests.NewCommonRequest() 148 request.Domain = "ecs.aliyuncs.com" 149 request.Version = "2014-05-26" 150 request.ApiName = "DescribeInstanceStatus" 151 152 request.QueryParams["PageNumber"] = "1" 153 request.QueryParams["PageSize"] = "30" 154 request.TransToAcsRequest() 155 response := responses.NewCommonResponse() 156 origTestHookDo := hookDo 157 defer func() { hookDo = origTestHookDo }() 158 hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) { 159 return func(req *http.Request) (*http.Response, error) { 160 return mockResponse(200, "", nil) 161 } 162 } 163 err = client.DoAction(request, response) 164 assert.Nil(t, err) 165 assert.Equal(t, 200, response.GetHttpStatus()) 166 assert.Equal(t, "", response.GetHttpContentString()) 167 168 // Test when scheme is http, only http proxy is valid. 169 envHttpsProxy := os.Getenv("https_proxy") 170 os.Setenv("https_proxy", "https://127.0.0.1:9000") 171 err = client.DoAction(request, response) 172 assert.Nil(t, err) 173 trans, _ := client.httpClient.Transport.(*http.Transport) 174 assert.Nil(t, trans.Proxy) 175 176 // Test when host is in no_proxy, proxy is invalid 177 envNoProxy := os.Getenv("no_proxy") 178 os.Setenv("no_proxy", "ecs.aliyuncs.com") 179 envHttpProxy := os.Getenv("http_proxy") 180 os.Setenv("http_proxy", "http://127.0.0.1:8888") 181 err = client.DoAction(request, response) 182 assert.Nil(t, err) 183 trans, _ = client.httpClient.Transport.(*http.Transport) 184 assert.Nil(t, trans.Proxy) 185 186 client.SetNoProxy("ecs.testaliyuncs.com") 187 err = client.DoAction(request, response) 188 assert.Nil(t, err) 189 trans, _ = client.httpClient.Transport.(*http.Transport) 190 url, _ := trans.Proxy(nil) 191 assert.Equal(t, url.Scheme, "http") 192 assert.Equal(t, url.Host, "127.0.0.1:8888") 193 194 // Test when setting http proxy, client has a high priority than environment variable 195 client.SetHttpProxy("http://127.0.0.1:8080") 196 err = client.DoAction(request, response) 197 assert.Nil(t, err) 198 trans, _ = client.httpClient.Transport.(*http.Transport) 199 url, _ = trans.Proxy(nil) 200 assert.Equal(t, url.Scheme, "http") 201 assert.Equal(t, url.Host, "127.0.0.1:8080") 202 203 // Test when scheme is https, only https proxy is valid 204 request.Scheme = "https" 205 err = client.DoAction(request, response) 206 assert.Nil(t, err) 207 trans, _ = client.httpClient.Transport.(*http.Transport) 208 url, _ = trans.Proxy(nil) 209 assert.Equal(t, url.Scheme, "https") 210 assert.Equal(t, url.Host, "127.0.0.1:9000") 211 212 // Test when setting https proxy, client has a high priority than environment variable 213 client.SetHttpsProxy("https://username:password@127.0.0.1:6666") 214 err = client.DoAction(request, response) 215 assert.Nil(t, err) 216 trans, _ = client.httpClient.Transport.(*http.Transport) 217 url, _ = trans.Proxy(nil) 218 assert.Equal(t, url.Scheme, "https") 219 assert.Equal(t, url.Host, "127.0.0.1:6666") 220 assert.Equal(t, url.User.Username(), "username") 221 222 client.Shutdown() 223 os.Setenv("https_proxy", envHttpsProxy) 224 os.Setenv("http_proxy", envHttpProxy) 225 os.Setenv("no_proxy", envNoProxy) 226 assert.Equal(t, false, client.isRunning) 227} 228 229func Test_DoAction_HTTPSInsecure(t *testing.T) { 230 client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") 231 assert.Nil(t, err) 232 assert.NotNil(t, client) 233 234 client.SetHTTPSInsecure(true) 235 request := requests.NewCommonRequest() 236 request.Product = "Ram" 237 request.Version = "2015-05-01" 238 request.ApiName = "CreateRole" 239 request.Domain = "ecs.aliyuncs.com" 240 request.QueryParams["RegionId"] = os.Getenv("REGION_ID") 241 request.TransToAcsRequest() 242 response := responses.NewCommonResponse() 243 origTestHookDo := hookDo 244 defer func() { hookDo = origTestHookDo }() 245 hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) { 246 return func(req *http.Request) (*http.Response, error) { 247 return mockResponse(200, "", nil) 248 } 249 } 250 err = client.DoAction(request, response) 251 assert.Nil(t, err) 252 assert.Equal(t, 200, response.GetHttpStatus()) 253 assert.Equal(t, "", response.GetHttpContentString()) 254 trans := client.httpClient.Transport.(*http.Transport) 255 assert.Equal(t, true, trans.TLSClientConfig.InsecureSkipVerify) 256 257 request.SetHTTPSInsecure(false) 258 err = client.DoAction(request, response) 259 assert.Nil(t, err) 260 trans = client.httpClient.Transport.(*http.Transport) 261 assert.Equal(t, false, trans.TLSClientConfig.InsecureSkipVerify) 262 263 // Test when scheme is http, only http proxy is valid. 264 envHttpsProxy := os.Getenv("HTTPS_PROXY") 265 os.Setenv("HTTPS_PROXY", "https://127.0.0.1:9000") 266 err = client.DoAction(request, response) 267 assert.Nil(t, err) 268 trans, _ = client.httpClient.Transport.(*http.Transport) 269 assert.Nil(t, trans.Proxy) 270 271 // Test when host is in no_proxy, proxy is invalid 272 envNoProxy := os.Getenv("NO_PROXY") 273 os.Setenv("NO_PROXY", "ecs.aliyuncs.com") 274 envHttpProxy := os.Getenv("HTTP_PROXY") 275 os.Setenv("HTTP_PROXY", "http://127.0.0.1:8888") 276 err = client.DoAction(request, response) 277 assert.Nil(t, err) 278 trans, _ = client.httpClient.Transport.(*http.Transport) 279 assert.Nil(t, trans.Proxy) 280 281 client.SetNoProxy("ecs.testaliyuncs.com") 282 err = client.DoAction(request, response) 283 assert.Nil(t, err) 284 trans, _ = client.httpClient.Transport.(*http.Transport) 285 url, _ := trans.Proxy(nil) 286 assert.Equal(t, url.Scheme, "http") 287 assert.Equal(t, url.Host, "127.0.0.1:8888") 288 289 // Test when setting http proxy, client has a high priority than environment variable 290 client.SetHttpProxy("http://127.0.0.1:8080") 291 err = client.DoAction(request, response) 292 assert.Nil(t, err) 293 trans, _ = client.httpClient.Transport.(*http.Transport) 294 url, _ = trans.Proxy(nil) 295 assert.Equal(t, url.Scheme, "http") 296 assert.Equal(t, url.Host, "127.0.0.1:8080") 297 298 // Test when scheme is https, only https proxy is valid 299 request.Scheme = "https" 300 err = client.DoAction(request, response) 301 assert.Nil(t, err) 302 trans, _ = client.httpClient.Transport.(*http.Transport) 303 url, _ = trans.Proxy(nil) 304 assert.Equal(t, url.Scheme, "https") 305 assert.Equal(t, url.Host, "127.0.0.1:9000") 306 307 // Test when setting https proxy, client has a high priority than environment variable 308 client.SetHttpsProxy("https://127.0.0.1:6666") 309 err = client.DoAction(request, response) 310 assert.Nil(t, err) 311 trans, _ = client.httpClient.Transport.(*http.Transport) 312 url, _ = trans.Proxy(nil) 313 assert.Equal(t, url.Scheme, "https") 314 assert.Equal(t, url.Host, "127.0.0.1:6666") 315 316 client.Shutdown() 317 os.Setenv("HTTPS_PROXY", envHttpsProxy) 318 os.Setenv("HTTP_PROXY", envHttpProxy) 319 os.Setenv("NO_PROXY", envNoProxy) 320 assert.Equal(t, false, client.isRunning) 321} 322 323func Test_DoAction_Timeout(t *testing.T) { 324 client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") 325 assert.Nil(t, err) 326 assert.NotNil(t, client) 327 assert.Equal(t, true, client.isRunning) 328 request := requests.NewCommonRequest() 329 request.Domain = "ecs.aliyuncs.com" 330 request.Version = "2014-05-26" 331 request.ApiName = "DescribeInstanceStatus" 332 333 request.QueryParams["PageNumber"] = "1" 334 request.QueryParams["PageSize"] = "30" 335 request.TransToAcsRequest() 336 response := responses.NewCommonResponse() 337 origTestHookDo := hookDo 338 defer func() { hookDo = origTestHookDo }() 339 hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) { 340 return func(req *http.Request) (*http.Response, error) { 341 return mockResponse(400, "Server Internel Error", fmt.Errorf("read tcp")) 342 } 343 } 344 err = client.DoAction(request, response) 345 assert.NotNil(t, err) 346 assert.Equal(t, 0, response.GetHttpStatus()) 347 assert.Equal(t, "", response.GetHttpContentString()) 348 349 // Test set client timeout 350 client.SetReadTimeout(1 * time.Millisecond) 351 client.SetConnectTimeout(1 * time.Millisecond) 352 assert.Equal(t, 1*time.Millisecond, client.GetConnectTimeout()) 353 assert.Equal(t, 1*time.Millisecond, client.GetReadTimeout()) 354 client.config.AutoRetry = false 355 err = client.DoAction(request, response) 356 assert.NotNil(t, err) 357 assert.Equal(t, 0, response.GetHttpStatus()) 358 assert.Equal(t, "", response.GetHttpContentString()) 359 360 // Test set request timeout 361 request.SetReadTimeout(1 * time.Millisecond) 362 request.SetConnectTimeout(1 * time.Millisecond) 363 err = client.DoAction(request, response) 364 assert.NotNil(t, err) 365 assert.Equal(t, 0, response.GetHttpStatus()) 366 assert.Equal(t, "", response.GetHttpContentString()) 367 368 client.Shutdown() 369 assert.Equal(t, false, client.isRunning) 370} 371 372func Test_ProcessCommonRequest(t *testing.T) { 373 client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") 374 assert.Nil(t, err) 375 assert.NotNil(t, client) 376 377 request := requests.NewCommonRequest() 378 request.Domain = "ecs.aliyuncs.com" 379 request.Version = "2014-05-26" 380 request.ApiName = "DescribeInstanceStatus" 381 382 request.QueryParams["PageNumber"] = "1" 383 request.QueryParams["PageSize"] = "30" 384 385 origTestHookDo := hookDo 386 defer func() { hookDo = origTestHookDo }() 387 hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) { 388 return func(req *http.Request) (*http.Response, error) { 389 return mockResponse(400, "", fmt.Errorf("test error")) 390 } 391 } 392 resp, err := client.ProcessCommonRequest(request) 393 assert.NotNil(t, err) 394 assert.Contains(t, err.Error(), "test error") 395 assert.Equal(t, 0, resp.GetHttpStatus()) 396 assert.Equal(t, "", resp.GetHttpContentString()) 397} 398 399func mockServer(status int, json string) (server *httptest.Server) { 400 // Start a test server locally. 401 ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 402 w.WriteHeader(status) 403 w.Write([]byte(json)) 404 return 405 })) 406 return ts 407} 408 409func Test_DoAction_With500(t *testing.T) { 410 client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") 411 assert.Nil(t, err) 412 assert.NotNil(t, client) 413 assert.Equal(t, true, client.isRunning) 414 request := requests.NewCommonRequest() 415 request.Version = "2014-05-26" 416 request.ApiName = "DescribeInstanceStatus" 417 418 request.QueryParams["PageNumber"] = "1" 419 request.QueryParams["PageSize"] = "30" 420 request.TransToAcsRequest() 421 response := responses.NewCommonResponse() 422 ts := mockServer(500, "Server Internel Error") 423 defer ts.Close() 424 domain := strings.Replace(ts.URL, "http://", "", 1) 425 request.Domain = domain 426 err = client.DoAction(request, response) 427 assert.NotNil(t, err) 428 assert.Equal(t, 500, response.GetHttpStatus()) 429 assert.Equal(t, "Server Internel Error", response.GetHttpContentString()) 430} 431 432func TestClient_BuildRequestWithSigner(t *testing.T) { 433 client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") 434 assert.Nil(t, err) 435 assert.NotNil(t, client) 436 assert.Equal(t, true, client.isRunning) 437 request := requests.NewCommonRequest() 438 request.Domain = "ecs.aliyuncs.com" 439 request.Version = "2014-05-26" 440 request.ApiName = "DescribeInstanceStatus" 441 442 request.QueryParams["PageNumber"] = "1" 443 request.QueryParams["PageSize"] = "30" 444 request.RegionId = "regionid" 445 request.TransToAcsRequest() 446 client.config.UserAgent = "user_agent" 447 err = client.BuildRequestWithSigner(request, nil) 448 assert.Nil(t, err) 449} 450 451func TestClient_BuildRequestWithSigner1(t *testing.T) { 452 client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") 453 assert.Nil(t, err) 454 assert.NotNil(t, client) 455 assert.Equal(t, true, client.isRunning) 456 request := requests.NewCommonRequest() 457 request.Domain = "ecs.aliyuncs.com" 458 request.Version = "2014-05-26" 459 request.ApiName = "DescribeInstanceStatus" 460 461 request.QueryParams["PageNumber"] = "1" 462 request.QueryParams["PageSize"] = "30" 463 request.RegionId = "regionid" 464 request.TransToAcsRequest() 465 signer := &signertest{ 466 name: "signer", 467 } 468 err = client.BuildRequestWithSigner(request, signer) 469 assert.Nil(t, err) 470} 471 472func TestClient_ProcessCommonRequestWithSigner(t *testing.T) { 473 client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") 474 assert.Nil(t, err) 475 assert.NotNil(t, client) 476 assert.Equal(t, true, client.isRunning) 477 request := requests.NewCommonRequest() 478 request.Domain = "ecs.aliyuncs.com" 479 request.Version = "2014-05-26" 480 request.ApiName = "DescribeInstanceStatus" 481 482 request.QueryParams["PageNumber"] = "1" 483 request.QueryParams["PageSize"] = "30" 484 request.RegionId = "regionid" 485 signer := &signertest{ 486 name: "signer", 487 } 488 origTestHookDo := hookDo 489 defer func() { hookDo = origTestHookDo }() 490 hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) { 491 return func(req *http.Request) (*http.Response, error) { 492 return mockResponse(500, "Server Internel Error", fmt.Errorf("test error")) 493 } 494 } 495 resp, err := client.ProcessCommonRequestWithSigner(request, signer) 496 assert.NotNil(t, err) 497 assert.Contains(t, err.Error(), "test error") 498 assert.Equal(t, resp.GetHttpContentString(), "") 499} 500 501func TestClient_AppendUserAgent(t *testing.T) { 502 client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") 503 assert.Nil(t, err) 504 assert.NotNil(t, client) 505 assert.Equal(t, true, client.isRunning) 506 request := requests.NewCommonRequest() 507 request.Domain = "ecs.aliyuncs.com" 508 request.Version = "2014-05-26" 509 request.ApiName = "DescribeInstanceStatus" 510 511 request.RegionId = "regionid" 512 signer := &signertest{ 513 name: "signer", 514 } 515 request.TransToAcsRequest() 516 httpRequest, err := client.buildRequestWithSigner(request, signer) 517 assert.Nil(t, err) 518 assert.Equal(t, DefaultUserAgent, httpRequest.Header.Get("User-Agent")) 519 520 // Test set client useragent. 521 client.AppendUserAgent("test", "1.01") 522 httpRequest, err = client.buildRequestWithSigner(request, signer) 523 assert.Equal(t, DefaultUserAgent+" test/1.01", httpRequest.Header.Get("User-Agent")) 524 525 // Test set request useragent. And request useragent has a higner priority than client's. 526 request.AppendUserAgent("test", "2.01") 527 httpRequest, err = client.buildRequestWithSigner(request, signer) 528 assert.Equal(t, DefaultUserAgent+" test/2.01", httpRequest.Header.Get("User-Agent")) 529 530 client.AppendUserAgent("test", "2.02") 531 httpRequest, err = client.buildRequestWithSigner(request, signer) 532 assert.Equal(t, DefaultUserAgent+" test/2.01", httpRequest.Header.Get("User-Agent")) 533 534 // Test update request useragent. 535 request.AppendUserAgent("test", "2.02") 536 httpRequest, err = client.buildRequestWithSigner(request, signer) 537 assert.Equal(t, DefaultUserAgent+" test/2.02", httpRequest.Header.Get("User-Agent")) 538 539 // Test client can't modify DefaultUserAgent. 540 client.AppendUserAgent("core", "1.01") 541 httpRequest, err = client.buildRequestWithSigner(request, signer) 542 assert.Equal(t, DefaultUserAgent+" test/2.02", httpRequest.Header.Get("User-Agent")) 543 544 // Test request can't modify DefaultUserAgent. 545 request.AppendUserAgent("core", "1.01") 546 httpRequest, err = client.buildRequestWithSigner(request, signer) 547 assert.Equal(t, DefaultUserAgent+" test/2.02", httpRequest.Header.Get("User-Agent")) 548 549 request1 := requests.NewCommonRequest() 550 request1.Domain = "ecs.aliyuncs.com" 551 request1.Version = "2014-05-26" 552 request1.ApiName = "DescribeRegions" 553 request1.RegionId = "regionid" 554 request1.AppendUserAgent("sys", "1.01") 555 request1.TransToAcsRequest() 556 httpRequest, err = client.buildRequestWithSigner(request1, signer) 557 assert.Nil(t, err) 558 assert.Equal(t, DefaultUserAgent+" test/2.02 sys/1.01", httpRequest.Header.Get("User-Agent")) 559} 560 561func TestClient_ProcessCommonRequestWithSigner_Error(t *testing.T) { 562 client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") 563 assert.Nil(t, err) 564 assert.NotNil(t, client) 565 assert.Equal(t, true, client.isRunning) 566 request := requests.NewCommonRequest() 567 request.Domain = "ecs.aliyuncs.com" 568 request.Version = "2014-05-26" 569 request.ApiName = "DescribeInstanceStatus" 570 571 request.QueryParams["PageNumber"] = "1" 572 request.QueryParams["PageSize"] = "30" 573 request.RegionId = "regionid" 574 origTestHookDo := hookDo 575 defer func() { 576 hookDo = origTestHookDo 577 err := recover() 578 assert.NotNil(t, err) 579 }() 580 hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) { 581 return func(req *http.Request) (*http.Response, error) { 582 return mockResponse(500, "Server Internel Error", fmt.Errorf("test error")) 583 } 584 } 585 resp, err := client.ProcessCommonRequestWithSigner(request, nil) 586 assert.NotNil(t, err) 587 assert.Contains(t, err.Error(), "test error") 588 assert.Equal(t, resp.GetHttpContentString(), "Server Internel Error") 589} 590 591func TestClient_NewClientWithStsRoleNameOnEcs(t *testing.T) { 592 client, err := NewClientWithStsRoleNameOnEcs("regionid", "rolename") 593 assert.Nil(t, err) 594 assert.NotNil(t, client) 595 assert.Equal(t, true, client.isRunning) 596 config := client.GetConfig() 597 assert.NotNil(t, config) 598 err = client.AddAsyncTask(nil) 599 assert.NotNil(t, err) 600} 601 602func TestClient_NewClientWithStsRoleArn(t *testing.T) { 603 client, err := NewClientWithStsRoleArn("regionid", "acesskeyid", "accesskeysecret", "rolearn", "rolesessionname") 604 assert.Nil(t, err) 605 assert.NotNil(t, client) 606 assert.Equal(t, true, client.isRunning) 607 task := func() {} 608 client.asyncTaskQueue = make(chan func(), 1) 609 err = client.AddAsyncTask(task) 610 assert.Nil(t, err) 611 client.Shutdown() 612 assert.Equal(t, false, client.isRunning) 613} 614 615func TestInitWithProviderChain(t *testing.T) { 616 617 //testcase1: No any environment variable 618 c, err := NewClientWithProvider("cn-hangzhou") 619 assert.Empty(t, c) 620 assert.EqualError(t, err, "No credential found") 621 622 //testcase2: AK 623 os.Setenv(provider.ENVAccessKeyID, "AccessKeyId") 624 os.Setenv(provider.ENVAccessKeySecret, "AccessKeySecret") 625 626 c, err = NewClientWithProvider("cn-hangzhou") 627 assert.Nil(t, err) 628 expC, err := NewClientWithAccessKey("cn-hangzhou", "AccessKeyId", "AccessKeySecret") 629 assert.Nil(t, err) 630 assert.Equal(t, expC, c) 631 632 //testcase3:AK value is "" 633 os.Setenv(provider.ENVAccessKeyID, "") 634 os.Setenv(provider.ENVAccessKeySecret, "bbbb") 635 c, err = NewClientWithProvider("cn-hangzhou") 636 assert.EqualError(t, err, "Environmental variable (ALIBABACLOUD_ACCESS_KEY_ID or ALIBABACLOUD_ACCESS_KEY_SECRET) is empty") 637 assert.Empty(t, c) 638 639 //testcase4: Profile value is "" 640 os.Unsetenv(provider.ENVAccessKeyID) 641 os.Unsetenv(provider.ENVAccessKeySecret) 642 os.Setenv(provider.ENVCredentialFile, "") 643 c, err = NewClientWithProvider("cn-hangzhou") 644 assert.Empty(t, c) 645 assert.EqualError(t, err, "Environment variable 'ALIBABA_CLOUD_CREDENTIALS_FILE' cannot be empty") 646 647 //testcase5: Profile 648 os.Setenv(provider.ENVCredentialFile, "./profile") 649 c, err = NewClientWithProvider("cn-hangzhou") 650 assert.Empty(t, c) 651 assert.NotNil(t, err) 652 //testcase6:Instances 653 os.Unsetenv(provider.ENVCredentialFile) 654 os.Setenv(provider.ENVEcsMetadata, "") 655 c, err = NewClientWithProvider("cn-hangzhou") 656 assert.Empty(t, c) 657 assert.EqualError(t, err, "Environmental variable 'ALIBABA_CLOUD_ECS_METADATA' are empty") 658 659 //testcase7: Custom Providers 660 c, err = NewClientWithProvider("cn-hangzhou", provider.ProviderProfile, provider.ProviderEnv) 661 assert.Empty(t, c) 662 assert.EqualError(t, err, "No credential found") 663 664} 665 666func TestNewClientWithBearerToken(t *testing.T) { 667 client, err := NewClientWithBearerToken("cn-hangzhou", "Bearer.Token") 668 assert.Nil(t, err) 669 assert.NotNil(t, client) 670} 671