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