vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/client_test.go

   1 // client test
   2 // use gocheck, install gocheck to execute "go get gopkg.in/check.v1",
   3 // see https://labix.org/gocheck
   4
   5 package oss
   6
   7 import (
   8         "encoding/json"
   9         "encoding/xml"
  10         "fmt"
  11         "io/ioutil"
  12         "log"
  13         "math/rand"
  14         "net"
  15         "net/http"
  16         "os"
  17         "reflect"
  18         "runtime"
  19         "strconv"
  20         "strings"
  21         "testing"
  22         "time"
  23
  24         . "gopkg.in/check.v1"
  25 )
  26
  27 // Test hooks up gocheck into the "go test" runner.
  28 func Test(t *testing.T) {
  29         TestingT(t)
  30 }
  31
  32 type OssClientSuite struct{}
  33
  34 var _ = Suite(&OssClientSuite{})
  35
  36 var (
  37         // Endpoint/ID/Key
  38         endpoint  = os.Getenv("OSS_TEST_ENDPOINT")
  39         accessID  = os.Getenv("OSS_TEST_ACCESS_KEY_ID")
  40         accessKey = os.Getenv("OSS_TEST_ACCESS_KEY_SECRET")
  41         accountID = os.Getenv("OSS_TEST_ACCOUNT_ID")
  42
  43         // Proxy
  44         proxyHost   = os.Getenv("OSS_TEST_PROXY_HOST")
  45         proxyUser   = os.Getenv("OSS_TEST_PROXY_USER")
  46         proxyPasswd = os.Getenv("OSS_TEST_PROXY_PASSWORD")
  47
  48         // STS
  49         stsaccessID  = os.Getenv("OSS_TEST_STS_ID")
  50         stsaccessKey = os.Getenv("OSS_TEST_STS_KEY")
  51         stsARN       = os.Getenv("OSS_TEST_STS_ARN")
  52
  53         // Credential
  54         credentialAccessID  = os.Getenv("OSS_CREDENTIAL_KEY_ID")
  55         credentialAccessKey = os.Getenv("OSS_CREDENTIAL_KEY_SECRET")
  56         credentialUID       = os.Getenv("OSS_CREDENTIAL_UID")
  57 )
  58
  59 var (
  60         // prefix of bucket name for bucket ops test
  61         bucketNamePrefix = "go-sdk-test-bucket-"
  62         // bucket name for object ops test
  63         bucketName        = bucketNamePrefix + RandLowStr(6)
  64         archiveBucketName = bucketNamePrefix + "arch-" + RandLowStr(6)
  65         // object name for object ops test
  66         objectNamePrefix = "go-sdk-test-object-"
  67         // sts region is one and only hangzhou
  68         stsRegion = "cn-hangzhou"
  69         // Credentials
  70         credentialBucketName = bucketNamePrefix + RandLowStr(6)
  71 )
  72
  73 var (
  74         logPath            = "go_sdk_test_" + time.Now().Format("20060102_150405") + ".log"
  75         testLogFile, _     = os.OpenFile(logPath, os.O_RDWR|os.O_CREATE, 0664)
  76         testLogger         = log.New(testLogFile, "", log.Ldate|log.Ltime|log.Lshortfile)
  77         letters            = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
  78         timeoutInOperation = 3 * time.Second
  79 )
  80
  81 func RandStr(n int) string {
  82         b := make([]rune, n)
  83         randMarker := rand.New(rand.NewSource(time.Now().UnixNano()))
  84         for i := range b {
  85                 b[i] = letters[randMarker.Intn(len(letters))]
  86         }
  87         return string(b)
  88 }
  89
  90 func CreateFile(fileName, content string, c *C) {
  91         fout, err := os.Create(fileName)
  92         defer fout.Close()
  93         c.Assert(err, IsNil)
  94         _, err = fout.WriteString(content)
  95         c.Assert(err, IsNil)
  96 }
  97
  98 func RandLowStr(n int) string {
  99         return strings.ToLower(RandStr(n))
 100 }
 101
 102 func ForceDeleteBucket(client *Client, bucketName string, c *C) {
 103         bucket, err := client.Bucket(bucketName)
 104         c.Assert(err, IsNil)
 105
 106         // Delete Object
 107         marker := Marker("")
 108         for {
 109                 lor, err := bucket.ListObjects(marker)
 110                 c.Assert(err, IsNil)
 111                 for _, object := range lor.Objects {
 112                         err = bucket.DeleteObject(object.Key)
 113                         c.Assert(err, IsNil)
 114                 }
 115                 marker = Marker(lor.NextMarker)
 116                 if !lor.IsTruncated {
 117                         break
 118                 }
 119         }
 120
 121         // Delete Object Versions and DeleteMarks
 122         keyMarker := KeyMarker("")
 123         versionIdMarker := VersionIdMarker("")
 124         options := []Option{keyMarker, versionIdMarker}
 125         for {
 126                 lor, err := bucket.ListObjectVersions(options...)
 127                 if err != nil {
 128                         break
 129                 }
 130
 131                 for _, object := range lor.ObjectDeleteMarkers {
 132                         err = bucket.DeleteObject(object.Key, VersionId(object.VersionId))
 133                         c.Assert(err, IsNil)
 134                 }
 135
 136                 for _, object := range lor.ObjectVersions {
 137                         err = bucket.DeleteObject(object.Key, VersionId(object.VersionId))
 138                         c.Assert(err, IsNil)
 139                 }
 140
 141                 keyMarker = KeyMarker(lor.NextKeyMarker)
 142                 versionIdMarker := VersionIdMarker(lor.NextVersionIdMarker)
 143                 options = []Option{keyMarker, versionIdMarker}
 144
 145                 if !lor.IsTruncated {
 146                         break
 147                 }
 148         }
 149
 150         // Delete Part
 151         keyMarker = KeyMarker("")
 152         uploadIDMarker := UploadIDMarker("")
 153         for {
 154                 lmur, err := bucket.ListMultipartUploads(keyMarker, uploadIDMarker)
 155                 c.Assert(err, IsNil)
 156                 for _, upload := range lmur.Uploads {
 157                         var imur = InitiateMultipartUploadResult{Bucket: bucketName,
 158                                 Key: upload.Key, UploadID: upload.UploadID}
 159                         err = bucket.AbortMultipartUpload(imur)
 160                         c.Assert(err, IsNil)
 161                 }
 162                 keyMarker = KeyMarker(lmur.NextKeyMarker)
 163                 uploadIDMarker = UploadIDMarker(lmur.NextUploadIDMarker)
 164                 if !lmur.IsTruncated {
 165                         break
 166                 }
 167         }
 168
 169         // delete live channel
 170         strMarker := ""
 171         for {
 172                 result, err := bucket.ListLiveChannel(Marker(strMarker))
 173                 c.Assert(err, IsNil)
 174
 175                 for _, channel := range result.LiveChannel {
 176                         err := bucket.DeleteLiveChannel(channel.Name)
 177                         c.Assert(err, IsNil)
 178                 }
 179
 180                 if result.IsTruncated {
 181                         strMarker = result.NextMarker
 182                 } else {
 183                         break
 184                 }
 185         }
 186
 187         // Delete Bucket
 188         err = client.DeleteBucket(bucketName)
 189         c.Assert(err, IsNil)
 190 }
 191
 192 // SetUpSuite runs once when the suite starts running
 193 func (s *OssClientSuite) SetUpSuite(c *C) {
 194         client, err := New(endpoint, accessID, accessKey)
 195         c.Assert(err, IsNil)
 196
 197         lbr, err := client.ListBuckets(Prefix(bucketNamePrefix), MaxKeys(1000))
 198         c.Assert(err, IsNil)
 199
 200         for _, bucket := range lbr.Buckets {
 201                 ForceDeleteBucket(client, bucket.Name, c)
 202         }
 203
 204         testLogger.Println("test client started")
 205 }
 206
 207 // TearDownSuite runs before each test or benchmark starts running
 208 func (s *OssClientSuite) TearDownSuite(c *C) {
 209         client, err := New(endpoint, accessID, accessKey)
 210         c.Assert(err, IsNil)
 211
 212         lbr, err := client.ListBuckets(Prefix(bucketNamePrefix), MaxKeys(1000))
 213         c.Assert(err, IsNil)
 214
 215         for _, bucket := range lbr.Buckets {
 216                 s.deleteBucket(client, bucket.Name, c)
 217         }
 218
 219         testLogger.Println("test client completed")
 220 }
 221
 222 func (s *OssClientSuite) deleteBucket(client *Client, bucketName string, c *C) {
 223         ForceDeleteBucket(client, bucketName, c)
 224 }
 225
 226 // SetUpTest runs after each test or benchmark runs
 227 func (s *OssClientSuite) SetUpTest(c *C) {
 228 }
 229
 230 // TearDownTest runs once after all tests or benchmarks have finished running
 231 func (s *OssClientSuite) TearDownTest(c *C) {
 232 }
 233
 234 // TestCreateBucket
 235 func (s *OssClientSuite) TestCreateBucket(c *C) {
 236         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
 237
 238         client, err := New(endpoint, accessID, accessKey)
 239         c.Assert(err, IsNil)
 240
 241         // Create
 242         client.DeleteBucket(bucketNameTest)
 243         err = client.CreateBucket(bucketNameTest)
 244         c.Assert(err, IsNil)
 245         //sleep 3 seconds after create bucket
 246         time.Sleep(timeoutInOperation)
 247
 248         // verify bucket is exist
 249         found, err := client.IsBucketExist(bucketNameTest)
 250         c.Assert(err, IsNil)
 251         c.Assert(found, Equals, true)
 252
 253         res, err := client.GetBucketACL(bucketNameTest)
 254         c.Assert(err, IsNil)
 255         c.Assert(res.ACL, Equals, string(ACLPrivate))
 256
 257         err = client.DeleteBucket(bucketNameTest)
 258         c.Assert(err, IsNil)
 259         time.Sleep(timeoutInOperation)
 260
 261         // CreateBucket creates with ACLPublicRead
 262         err = client.CreateBucket(bucketNameTest, ACL(ACLPublicRead))
 263         c.Assert(err, IsNil)
 264         time.Sleep(timeoutInOperation)
 265
 266         res, err = client.GetBucketACL(bucketNameTest)
 267         c.Assert(err, IsNil)
 268         c.Assert(res.ACL, Equals, string(ACLPublicRead))
 269
 270         err = client.DeleteBucket(bucketNameTest)
 271         c.Assert(err, IsNil)
 272         time.Sleep(timeoutInOperation)
 273
 274         // ACLPublicReadWrite
 275         err = client.CreateBucket(bucketNameTest, ACL(ACLPublicReadWrite))
 276         c.Assert(err, IsNil)
 277         time.Sleep(timeoutInOperation)
 278
 279         res, err = client.GetBucketACL(bucketNameTest)
 280         c.Assert(err, IsNil)
 281         c.Assert(res.ACL, Equals, string(ACLPublicReadWrite))
 282
 283         err = client.DeleteBucket(bucketNameTest)
 284         c.Assert(err, IsNil)
 285         time.Sleep(timeoutInOperation)
 286
 287         // ACLPrivate
 288         err = client.CreateBucket(bucketNameTest, ACL(ACLPrivate))
 289         c.Assert(err, IsNil)
 290         time.Sleep(timeoutInOperation)
 291
 292         res, err = client.GetBucketACL(bucketNameTest)
 293         c.Assert(err, IsNil)
 294         c.Assert(res.ACL, Equals, string(ACLPrivate))
 295
 296         // Delete
 297         err = client.DeleteBucket(bucketNameTest)
 298         c.Assert(err, IsNil)
 299
 300         // Create bucket with configuration and test GetBucketInfo
 301         for _, storage := range []StorageClassType{StorageStandard, StorageIA, StorageArchive, StorageColdArchive} {
 302                 bucketNameTest := bucketNamePrefix + RandLowStr(6)
 303                 err = client.CreateBucket(bucketNameTest, StorageClass(storage), ACL(ACLPublicRead))
 304                 c.Assert(err, IsNil)
 305                 time.Sleep(timeoutInOperation)
 306
 307                 res, err := client.GetBucketInfo(bucketNameTest)
 308                 c.Assert(err, IsNil)
 309                 c.Assert(res.BucketInfo.Name, Equals, bucketNameTest)
 310                 c.Assert(res.BucketInfo.StorageClass, Equals, string(storage))
 311                 c.Assert(res.BucketInfo.ACL, Equals, string(ACLPublicRead))
 312
 313                 // Delete
 314                 err = client.DeleteBucket(bucketNameTest)
 315                 c.Assert(err, IsNil)
 316         }
 317
 318         // Error put bucket with configuration
 319         err = client.CreateBucket("ERRORBUCKETNAME", StorageClass(StorageArchive))
 320         c.Assert(err, NotNil)
 321
 322         // Create bucket with configuration and test ListBuckets
 323         for _, storage := range []StorageClassType{StorageStandard, StorageIA, StorageArchive, StorageColdArchive} {
 324                 bucketNameTest := bucketNamePrefix + RandLowStr(6)
 325                 err = client.CreateBucket(bucketNameTest, StorageClass(storage))
 326                 c.Assert(err, IsNil)
 327                 time.Sleep(timeoutInOperation)
 328
 329                 res, err := client.GetBucketInfo(bucketNameTest)
 330                 c.Assert(err, IsNil)
 331                 c.Assert(res.BucketInfo.Name, Equals, bucketNameTest)
 332                 c.Assert(res.BucketInfo.StorageClass, Equals, string(storage))
 333
 334                 // Delete
 335                 err = client.DeleteBucket(bucketNameTest)
 336                 c.Assert(err, IsNil)
 337         }
 338 }
 339
 340 func (s *OssClientSuite) TestCreateBucketRedundancyType(c *C) {
 341         bucketNameTest := bucketNamePrefix + RandLowStr(6)
 342         client, err := New(endpoint, accessID, accessKey)
 343         c.Assert(err, IsNil)
 344
 345         // CreateBucket creates without property
 346         err = client.CreateBucket(bucketNameTest)
 347         c.Assert(err, IsNil)
 348         client.DeleteBucket(bucketNameTest)
 349         time.Sleep(timeoutInOperation)
 350
 351         // CreateBucket creates with RedundancyZRS
 352         err = client.CreateBucket(bucketNameTest, RedundancyType(RedundancyZRS))
 353         c.Assert(err, IsNil)
 354
 355         res, err := client.GetBucketInfo(bucketNameTest)
 356         c.Assert(err, IsNil)
 357         c.Assert(res.BucketInfo.RedundancyType, Equals, string(RedundancyZRS))
 358         client.DeleteBucket(bucketNameTest)
 359         time.Sleep(timeoutInOperation)
 360
 361         // CreateBucket creates with RedundancyLRS
 362         err = client.CreateBucket(bucketNameTest, RedundancyType(RedundancyLRS))
 363         c.Assert(err, IsNil)
 364
 365         res, err = client.GetBucketInfo(bucketNameTest)
 366         c.Assert(err, IsNil)
 367         c.Assert(res.BucketInfo.RedundancyType, Equals, string(RedundancyLRS))
 368         c.Assert(res.BucketInfo.StorageClass, Equals, string(StorageStandard))
 369         client.DeleteBucket(bucketNameTest)
 370         time.Sleep(timeoutInOperation)
 371
 372         // CreateBucket creates with ACLPublicRead RedundancyZRS
 373         err = client.CreateBucket(bucketNameTest, ACL(ACLPublicRead), RedundancyType(RedundancyZRS))
 374         c.Assert(err, IsNil)
 375
 376         res, err = client.GetBucketInfo(bucketNameTest)
 377         c.Assert(err, IsNil)
 378         c.Assert(res.BucketInfo.RedundancyType, Equals, string(RedundancyZRS))
 379         c.Assert(res.BucketInfo.ACL, Equals, string(ACLPublicRead))
 380         client.DeleteBucket(bucketNameTest)
 381 }
 382
 383 // TestCreateBucketNegative
 384 func (s *OssClientSuite) TestCreateBucketNegative(c *C) {
 385         client, err := New(endpoint, accessID, accessKey)
 386         c.Assert(err, IsNil)
 387
 388         // Bucket name invalid
 389         err = client.CreateBucket("xx")
 390         c.Assert(err, NotNil)
 391
 392         err = client.CreateBucket("XXXX")
 393         c.Assert(err, NotNil)
 394         testLogger.Println(err)
 395
 396         err = client.CreateBucket("_bucket")
 397         c.Assert(err, NotNil)
 398         testLogger.Println(err)
 399
 400         // ACL invalid
 401         err = client.CreateBucket(bucketNamePrefix+RandLowStr(6), ACL("InvaldAcl"))
 402         c.Assert(err, NotNil)
 403         testLogger.Println(err)
 404 }
 405
 406 // TestDeleteBucket
 407 func (s *OssClientSuite) TestDeleteBucket(c *C) {
 408         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
 409
 410         client, err := New(endpoint, accessID, accessKey)
 411         c.Assert(err, IsNil)
 412
 413         // Create
 414         err = client.CreateBucket(bucketNameTest)
 415         c.Assert(err, IsNil)
 416         time.Sleep(timeoutInOperation)
 417
 418         // Check
 419         found, err := client.IsBucketExist(bucketNameTest)
 420         c.Assert(err, IsNil)
 421         c.Assert(found, Equals, true)
 422
 423         // Delete
 424         err = client.DeleteBucket(bucketNameTest)
 425         c.Assert(err, IsNil)
 426         time.Sleep(timeoutInOperation)
 427
 428         // Check
 429         found, err = client.IsBucketExist(bucketNameTest)
 430         c.Assert(err, IsNil)
 431         c.Assert(found, Equals, false)
 432
 433         err = client.DeleteBucket(bucketNameTest)
 434         c.Assert(err, NotNil)
 435 }
 436
 437 // TestDeleteBucketNegative
 438 func (s *OssClientSuite) TestDeleteBucketNegative(c *C) {
 439         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
 440
 441         client, err := New(endpoint, accessID, accessKey)
 442         c.Assert(err, IsNil)
 443
 444         // Bucket name invalid
 445         err = client.DeleteBucket("xx")
 446         c.Assert(err, NotNil)
 447
 448         err = client.DeleteBucket("XXXX")
 449         c.Assert(err, NotNil)
 450
 451         err = client.DeleteBucket("_bucket")
 452         c.Assert(err, NotNil)
 453
 454         // Delete no exist bucket
 455         err = client.DeleteBucket("notexist")
 456         c.Assert(err, NotNil)
 457
 458         // No permission to delete, this ak/sk for js sdk
 459         err = client.CreateBucket(bucketNameTest)
 460         c.Assert(err, IsNil)
 461
 462         accessID := "<accessKeyId>"
 463         accessKey := "<accessKeySecret>"
 464         clientOtherUser, err := New(endpoint, accessID, accessKey)
 465         c.Assert(err, IsNil)
 466
 467         err = clientOtherUser.DeleteBucket(bucketNameTest)
 468         c.Assert(err, NotNil)
 469
 470         err = client.DeleteBucket(bucketNameTest)
 471         c.Assert(err, IsNil)
 472 }
 473
 474 // TestListBucket
 475 func (s *OssClientSuite) TestListBucket(c *C) {
 476         var prefix = bucketNamePrefix + RandLowStr(6)
 477         var bucketNameLbOne = prefix + "tlb1"
 478         var bucketNameLbTwo = prefix + "tlb2"
 479         var bucketNameLbThree = prefix + "tlb3"
 480
 481         client, err := New(endpoint, accessID, accessKey)
 482         c.Assert(err, IsNil)
 483
 484         // CreateBucket
 485         err = client.CreateBucket(bucketNameLbOne)
 486         c.Assert(err, IsNil)
 487         err = client.CreateBucket(bucketNameLbTwo)
 488         c.Assert(err, IsNil)
 489         err = client.CreateBucket(bucketNameLbThree)
 490         c.Assert(err, IsNil)
 491
 492         // ListBuckets, specified prefix
 493         var respHeader http.Header
 494         lbr, err := client.ListBuckets(Prefix(prefix), MaxKeys(2), GetResponseHeader(&respHeader))
 495         c.Assert(GetRequestId(respHeader) != "", Equals, true)
 496         c.Assert(err, IsNil)
 497         c.Assert(len(lbr.Buckets), Equals, 2)
 498
 499         // ListBuckets, specified max keys
 500         lbr, err = client.ListBuckets(MaxKeys(2))
 501         c.Assert(err, IsNil)
 502         c.Assert(len(lbr.Buckets), Equals, 2)
 503
 504         // ListBuckets, specified max keys
 505         lbr, err = client.ListBuckets(Marker(bucketNameLbOne), MaxKeys(1))
 506         c.Assert(err, IsNil)
 507         c.Assert(len(lbr.Buckets), Equals, 1)
 508
 509         // ListBuckets, specified max keys
 510         lbr, err = client.ListBuckets(Marker(bucketNameLbOne))
 511         c.Assert(err, IsNil)
 512         c.Assert(len(lbr.Buckets) >= 2, Equals, true)
 513
 514         // DeleteBucket
 515         err = client.DeleteBucket(bucketNameLbOne)
 516         c.Assert(err, IsNil)
 517         err = client.DeleteBucket(bucketNameLbTwo)
 518         c.Assert(err, IsNil)
 519         err = client.DeleteBucket(bucketNameLbThree)
 520         c.Assert(err, IsNil)
 521 }
 522
 523 // TestListBucket
 524 func (s *OssClientSuite) TestIsBucketExist(c *C) {
 525         var prefix = bucketNamePrefix + RandLowStr(6)
 526         var bucketNameLbOne = prefix + "tibe1"
 527         var bucketNameLbTwo = prefix + "tibe11"
 528         var bucketNameLbThree = prefix + "tibe111"
 529
 530         client, err := New(endpoint, accessID, accessKey)
 531         c.Assert(err, IsNil)
 532
 533         // CreateBucket
 534         err = client.CreateBucket(bucketNameLbOne)
 535         c.Assert(err, IsNil)
 536         err = client.CreateBucket(bucketNameLbTwo)
 537         c.Assert(err, IsNil)
 538         err = client.CreateBucket(bucketNameLbThree)
 539         c.Assert(err, IsNil)
 540
 541         // Exist
 542         exist, err := client.IsBucketExist(bucketNameLbTwo)
 543         c.Assert(err, IsNil)
 544         c.Assert(exist, Equals, true)
 545
 546         exist, err = client.IsBucketExist(bucketNameLbThree)
 547         c.Assert(err, IsNil)
 548         c.Assert(exist, Equals, true)
 549
 550         exist, err = client.IsBucketExist(bucketNameLbOne)
 551         c.Assert(err, IsNil)
 552         c.Assert(exist, Equals, true)
 553
 554         // Not exist
 555         exist, err = client.IsBucketExist(prefix + "tibe")
 556         c.Assert(err, IsNil)
 557         c.Assert(exist, Equals, false)
 558
 559         exist, err = client.IsBucketExist(prefix + "tibe1111")
 560         c.Assert(err, IsNil)
 561         c.Assert(exist, Equals, false)
 562
 563         // Negative
 564         exist, err = client.IsBucketExist("BucketNameInvalid")
 565         c.Assert(err, NotNil)
 566
 567         // DeleteBucket
 568         err = client.DeleteBucket(bucketNameLbOne)
 569         c.Assert(err, IsNil)
 570         err = client.DeleteBucket(bucketNameLbTwo)
 571         c.Assert(err, IsNil)
 572         err = client.DeleteBucket(bucketNameLbThree)
 573         c.Assert(err, IsNil)
 574 }
 575
 576 // TestSetBucketAcl
 577 func (s *OssClientSuite) TestSetBucketAcl(c *C) {
 578         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
 579
 580         client, err := New(endpoint, accessID, accessKey)
 581         c.Assert(err, IsNil)
 582
 583         // Private
 584         err = client.CreateBucket(bucketNameTest)
 585         c.Assert(err, IsNil)
 586
 587         res, err := client.GetBucketACL(bucketNameTest)
 588         c.Assert(err, IsNil)
 589         c.Assert(res.ACL, Equals, string(ACLPrivate))
 590
 591         // Set ACL_PUBLIC_R
 592         err = client.SetBucketACL(bucketNameTest, ACLPublicRead)
 593         c.Assert(err, IsNil)
 594         time.Sleep(timeoutInOperation)
 595
 596         res, err = client.GetBucketACL(bucketNameTest)
 597         c.Assert(err, IsNil)
 598         c.Assert(res.ACL, Equals, string(ACLPublicRead))
 599
 600         // Set ACL_PUBLIC_RW
 601         err = client.SetBucketACL(bucketNameTest, ACLPublicReadWrite)
 602         c.Assert(err, IsNil)
 603         time.Sleep(timeoutInOperation)
 604
 605         res, err = client.GetBucketACL(bucketNameTest)
 606         c.Assert(err, IsNil)
 607         c.Assert(res.ACL, Equals, string(ACLPublicReadWrite))
 608
 609         // Set ACL_PUBLIC_RW
 610         err = client.SetBucketACL(bucketNameTest, ACLPrivate)
 611         c.Assert(err, IsNil)
 612         time.Sleep(timeoutInOperation)
 613
 614         res, err = client.GetBucketACL(bucketNameTest)
 615         c.Assert(err, IsNil)
 616         c.Assert(res.ACL, Equals, string(ACLPrivate))
 617
 618         err = client.DeleteBucket(bucketNameTest)
 619         c.Assert(err, IsNil)
 620 }
 621
 622 // TestSetBucketAclNegative
 623 func (s *OssClientSuite) TestBucketAclNegative(c *C) {
 624         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
 625
 626         client, err := New(endpoint, accessID, accessKey)
 627         c.Assert(err, IsNil)
 628
 629         err = client.CreateBucket(bucketNameTest)
 630         c.Assert(err, IsNil)
 631
 632         err = client.SetBucketACL(bucketNameTest, "InvalidACL")
 633         c.Assert(err, NotNil)
 634         testLogger.Println(err)
 635
 636         err = client.DeleteBucket(bucketNameTest)
 637         c.Assert(err, IsNil)
 638 }
 639
 640 // TestGetBucketAcl
 641 func (s *OssClientSuite) TestGetBucketAcl(c *C) {
 642         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
 643
 644         client, err := New(endpoint, accessID, accessKey)
 645         c.Assert(err, IsNil)
 646
 647         // Private
 648         err = client.CreateBucket(bucketNameTest)
 649         c.Assert(err, IsNil)
 650         time.Sleep(timeoutInOperation)
 651
 652         res, err := client.GetBucketACL(bucketNameTest)
 653         c.Assert(err, IsNil)
 654         c.Assert(res.ACL, Equals, string(ACLPrivate))
 655
 656         err = client.DeleteBucket(bucketNameTest)
 657         c.Assert(err, IsNil)
 658         time.Sleep(timeoutInOperation)
 659
 660         // PublicRead
 661         err = client.CreateBucket(bucketNameTest, ACL(ACLPublicRead))
 662         c.Assert(err, IsNil)
 663         time.Sleep(timeoutInOperation)
 664
 665         res, err = client.GetBucketACL(bucketNameTest)
 666         c.Assert(err, IsNil)
 667         c.Assert(res.ACL, Equals, string(ACLPublicRead))
 668
 669         err = client.DeleteBucket(bucketNameTest)
 670         c.Assert(err, IsNil)
 671         time.Sleep(timeoutInOperation)
 672
 673         // PublicReadWrite
 674         err = client.CreateBucket(bucketNameTest, ACL(ACLPublicReadWrite))
 675         c.Assert(err, IsNil)
 676         time.Sleep(timeoutInOperation)
 677
 678         res, err = client.GetBucketACL(bucketNameTest)
 679         c.Assert(err, IsNil)
 680         c.Assert(res.ACL, Equals, string(ACLPublicReadWrite))
 681
 682         err = client.DeleteBucket(bucketNameTest)
 683         c.Assert(err, IsNil)
 684 }
 685
 686 // TestGetBucketAcl
 687 func (s *OssClientSuite) TestGetBucketLocation(c *C) {
 688         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
 689
 690         client, err := New(endpoint, accessID, accessKey)
 691         c.Assert(err, IsNil)
 692
 693         // Private
 694         err = client.CreateBucket(bucketNameTest)
 695         c.Assert(err, IsNil)
 696
 697         loc, err := client.GetBucketLocation(bucketNameTest)
 698         c.Assert(strings.HasPrefix(loc, "oss-"), Equals, true)
 699
 700         err = client.DeleteBucket(bucketNameTest)
 701         c.Assert(err, IsNil)
 702 }
 703
 704 // TestGetBucketLocationNegative
 705 func (s *OssClientSuite) TestGetBucketLocationNegative(c *C) {
 706         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
 707
 708         client, err := New(endpoint, accessID, accessKey)
 709         c.Assert(err, IsNil)
 710
 711         // Not exist
 712         _, err = client.GetBucketLocation(bucketNameTest)
 713         c.Assert(err, NotNil)
 714
 715         // Not exist
 716         _, err = client.GetBucketLocation("InvalidBucketName_")
 717         c.Assert(err, NotNil)
 718 }
 719
 720 // TestSetBucketLifecycle
 721 func (s *OssClientSuite) TestSetBucketLifecycle(c *C) {
 722         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
 723         var rule1 = BuildLifecycleRuleByDate("rule1", "one", true, 2015, 11, 11)
 724         var rule2 = BuildLifecycleRuleByDays("rule2", "two", true, 3)
 725
 726         client, err := New(endpoint, accessID, accessKey)
 727         c.Assert(err, IsNil)
 728
 729         err = client.CreateBucket(bucketNameTest)
 730         c.Assert(err, IsNil)
 731
 732         // Set single rule
 733         var rules = []LifecycleRule{rule1}
 734         err = client.SetBucketLifecycle(bucketNameTest, rules)
 735         c.Assert(err, IsNil)
 736         // Double set rule
 737         err = client.SetBucketLifecycle(bucketNameTest, rules)
 738         c.Assert(err, IsNil)
 739
 740         res, err := client.GetBucketLifecycle(bucketNameTest)
 741         c.Assert(err, IsNil)
 742         c.Assert(len(res.Rules), Equals, 1)
 743         c.Assert(res.Rules[0].ID, Equals, "rule1")
 744
 745         err = client.DeleteBucketLifecycle(bucketNameTest)
 746         c.Assert(err, IsNil)
 747
 748         // Set two rules
 749         rules = []LifecycleRule{rule1, rule2}
 750         err = client.SetBucketLifecycle(bucketNameTest, rules)
 751         c.Assert(err, IsNil)
 752
 753         // Eliminate effect of cache
 754         time.Sleep(timeoutInOperation)
 755
 756         res, err = client.GetBucketLifecycle(bucketNameTest)
 757         c.Assert(err, IsNil)
 758         c.Assert(len(res.Rules), Equals, 2)
 759         c.Assert(res.Rules[0].ID, Equals, "rule1")
 760         c.Assert(res.Rules[1].ID, Equals, "rule2")
 761
 762         err = client.DeleteBucket(bucketNameTest)
 763         c.Assert(err, IsNil)
 764 }
 765
 766 // TestSetBucketLifecycleNew
 767 func (s *OssClientSuite) TestSetBucketLifecycleNew(c *C) {
 768         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
 769
 770         client, err := New(endpoint, accessID, accessKey)
 771         c.Assert(err, IsNil)
 772
 773         err = client.CreateBucket(bucketNameTest)
 774         c.Assert(err, IsNil)
 775
 776         //invalid status of lifecyclerule
 777         expiration := LifecycleExpiration{
 778                 Days: 30,
 779         }
 780         rule := LifecycleRule{
 781                 ID:         "rule1",
 782                 Prefix:     "one",
 783                 Status:     "Invalid",
 784                 Expiration: &expiration,
 785         }
 786         rules := []LifecycleRule{rule}
 787         err = client.SetBucketLifecycle(bucketNameTest, rules)
 788         c.Assert(err, NotNil)
 789
 790         //invalid value of CreatedBeforeDate
 791         expiration = LifecycleExpiration{
 792                 CreatedBeforeDate: RandStr(10),
 793         }
 794         rule = LifecycleRule{
 795                 ID:         "rule1",
 796                 Prefix:     "one",
 797                 Status:     "Enabled",
 798                 Expiration: &expiration,
 799         }
 800         rules = []LifecycleRule{rule}
 801         err = client.SetBucketLifecycle(bucketNameTest, rules)
 802         c.Assert(err, NotNil)
 803
 804         //invalid value of Days
 805         abortMPU := LifecycleAbortMultipartUpload{
 806                 Days: -30,
 807         }
 808         rule = LifecycleRule{
 809                 ID:                   "rule1",
 810                 Prefix:               "one",
 811                 Status:               "Enabled",
 812                 AbortMultipartUpload: &abortMPU,
 813         }
 814         rules = []LifecycleRule{rule}
 815         err = client.SetBucketLifecycle(bucketNameTest, rules)
 816         c.Assert(err, NotNil)
 817
 818         expiration = LifecycleExpiration{
 819                 CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
 820         }
 821         rule1 := LifecycleRule{
 822                 ID:         "rule1",
 823                 Prefix:     "one",
 824                 Status:     "Enabled",
 825                 Expiration: &expiration,
 826         }
 827
 828         abortMPU = LifecycleAbortMultipartUpload{
 829                 Days: 30,
 830         }
 831         rule2 := LifecycleRule{
 832                 ID:                   "rule2",
 833                 Prefix:               "two",
 834                 Status:               "Enabled",
 835                 Expiration:           &expiration,
 836                 AbortMultipartUpload: &abortMPU,
 837         }
 838
 839         transition1 := LifecycleTransition{
 840                 Days:         3,
 841                 StorageClass: StorageIA,
 842         }
 843         transition2 := LifecycleTransition{
 844                 Days:         30,
 845                 StorageClass: StorageArchive,
 846         }
 847         transitions := []LifecycleTransition{transition1, transition2}
 848         rule3 := LifecycleRule{
 849                 ID:                   "rule3",
 850                 Prefix:               "three",
 851                 Status:               "Enabled",
 852                 AbortMultipartUpload: &abortMPU,
 853                 Transitions:          transitions,
 854         }
 855
 856         // Set single rule
 857         rules = []LifecycleRule{rule1}
 858         err = client.SetBucketLifecycle(bucketNameTest, rules)
 859         c.Assert(err, IsNil)
 860
 861         res, err := client.GetBucketLifecycle(bucketNameTest)
 862         c.Assert(err, IsNil)
 863         c.Assert(len(res.Rules), Equals, 1)
 864         c.Assert(res.Rules[0].ID, Equals, "rule1")
 865         c.Assert(res.Rules[0].Expiration, NotNil)
 866         c.Assert(res.Rules[0].Expiration.CreatedBeforeDate, Equals, "2015-11-11T00:00:00.000Z")
 867
 868         err = client.DeleteBucketLifecycle(bucketNameTest)
 869         c.Assert(err, IsNil)
 870
 871         // Set two rule: rule1 and rule2
 872         rules = []LifecycleRule{rule1, rule2}
 873         err = client.SetBucketLifecycle(bucketNameTest, rules)
 874         c.Assert(err, IsNil)
 875
 876         res, err = client.GetBucketLifecycle(bucketNameTest)
 877         c.Assert(err, IsNil)
 878         c.Assert(len(res.Rules), Equals, 2)
 879         c.Assert(res.Rules[0].ID, Equals, "rule1")
 880         c.Assert(res.Rules[0].Expiration, NotNil)
 881         c.Assert(res.Rules[0].Expiration.CreatedBeforeDate, Equals, "2015-11-11T00:00:00.000Z")
 882         c.Assert(res.Rules[1].ID, Equals, "rule2")
 883         c.Assert(res.Rules[1].Expiration, NotNil)
 884         c.Assert(res.Rules[1].Expiration.CreatedBeforeDate, Equals, "2015-11-11T00:00:00.000Z")
 885         c.Assert(res.Rules[1].AbortMultipartUpload, NotNil)
 886         c.Assert(res.Rules[1].AbortMultipartUpload.Days, Equals, 30)
 887
 888         err = client.DeleteBucketLifecycle(bucketNameTest)
 889         c.Assert(err, IsNil)
 890
 891         // Set two rule: rule2 and rule3
 892         rules = []LifecycleRule{rule2, rule3}
 893         err = client.SetBucketLifecycle(bucketNameTest, rules)
 894         c.Assert(err, IsNil)
 895
 896         res, err = client.GetBucketLifecycle(bucketNameTest)
 897         c.Assert(err, IsNil)
 898         c.Assert(len(res.Rules), Equals, 2)
 899         c.Assert(res.Rules[0].ID, Equals, "rule2")
 900         c.Assert(res.Rules[0].Expiration, NotNil)
 901         c.Assert(res.Rules[0].Expiration.CreatedBeforeDate, Equals, "2015-11-11T00:00:00.000Z")
 902         c.Assert(res.Rules[0].AbortMultipartUpload, NotNil)
 903         c.Assert(res.Rules[0].AbortMultipartUpload.Days, Equals, 30)
 904         c.Assert(res.Rules[1].ID, Equals, "rule3")
 905         c.Assert(res.Rules[1].AbortMultipartUpload, NotNil)
 906         c.Assert(res.Rules[1].AbortMultipartUpload.Days, Equals, 30)
 907         c.Assert(len(res.Rules[1].Transitions), Equals, 2)
 908         c.Assert(res.Rules[1].Transitions[0].StorageClass, Equals, StorageIA)
 909         c.Assert(res.Rules[1].Transitions[0].Days, Equals, 3)
 910         c.Assert(res.Rules[1].Transitions[1].StorageClass, Equals, StorageArchive)
 911         c.Assert(res.Rules[1].Transitions[1].Days, Equals, 30)
 912
 913         err = client.DeleteBucketLifecycle(bucketNameTest)
 914         c.Assert(err, IsNil)
 915
 916         // Set two rule: rule1 and rule3
 917         rules = []LifecycleRule{rule1, rule3}
 918         err = client.SetBucketLifecycle(bucketNameTest, rules)
 919         c.Assert(err, IsNil)
 920
 921         res, err = client.GetBucketLifecycle(bucketNameTest)
 922         c.Assert(err, IsNil)
 923         c.Assert(len(res.Rules), Equals, 2)
 924         c.Assert(res.Rules[0].ID, Equals, "rule1")
 925         c.Assert(res.Rules[0].Expiration, NotNil)
 926         c.Assert(res.Rules[0].Expiration.CreatedBeforeDate, Equals, "2015-11-11T00:00:00.000Z")
 927         c.Assert(res.Rules[1].ID, Equals, "rule3")
 928         c.Assert(res.Rules[1].AbortMultipartUpload, NotNil)
 929         c.Assert(res.Rules[1].AbortMultipartUpload.Days, Equals, 30)
 930         c.Assert(len(res.Rules[1].Transitions), Equals, 2)
 931         c.Assert(res.Rules[1].Transitions[0].StorageClass, Equals, StorageIA)
 932         c.Assert(res.Rules[1].Transitions[0].Days, Equals, 3)
 933         c.Assert(res.Rules[1].Transitions[1].StorageClass, Equals, StorageArchive)
 934         c.Assert(res.Rules[1].Transitions[1].Days, Equals, 30)
 935
 936         err = client.DeleteBucketLifecycle(bucketNameTest)
 937         c.Assert(err, IsNil)
 938
 939         // Set three rules
 940         rules = []LifecycleRule{rule1, rule2, rule3}
 941         err = client.SetBucketLifecycle(bucketNameTest, rules)
 942         c.Assert(err, IsNil)
 943
 944         res, err = client.GetBucketLifecycle(bucketNameTest)
 945         c.Assert(err, IsNil)
 946         c.Assert(len(res.Rules), Equals, 3)
 947         c.Assert(res.Rules[0].ID, Equals, "rule1")
 948         c.Assert(res.Rules[0].Expiration, NotNil)
 949         c.Assert(res.Rules[0].Expiration.CreatedBeforeDate, Equals, "2015-11-11T00:00:00.000Z")
 950         c.Assert(res.Rules[1].ID, Equals, "rule2")
 951         c.Assert(res.Rules[1].Expiration, NotNil)
 952         c.Assert(res.Rules[1].Expiration.CreatedBeforeDate, Equals, "2015-11-11T00:00:00.000Z")
 953         c.Assert(res.Rules[1].AbortMultipartUpload, NotNil)
 954         c.Assert(res.Rules[1].AbortMultipartUpload.Days, Equals, 30)
 955         c.Assert(res.Rules[2].ID, Equals, "rule3")
 956         c.Assert(res.Rules[2].AbortMultipartUpload, NotNil)
 957         c.Assert(res.Rules[2].AbortMultipartUpload.Days, Equals, 30)
 958         c.Assert(len(res.Rules[2].Transitions), Equals, 2)
 959         c.Assert(res.Rules[2].Transitions[0].StorageClass, Equals, StorageIA)
 960         c.Assert(res.Rules[2].Transitions[0].Days, Equals, 3)
 961         c.Assert(res.Rules[2].Transitions[1].StorageClass, Equals, StorageArchive)
 962         c.Assert(res.Rules[2].Transitions[1].Days, Equals, 30)
 963
 964         err = client.DeleteBucket(bucketNameTest)
 965         c.Assert(err, IsNil)
 966 }
 967
 968 // TestSetBucketLifecycleAboutVersionObject
 969 func (s *OssClientSuite) TestSetBucketLifecycleAboutVersionObject(c *C) {
 970         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
 971
 972         client, err := New(endpoint, accessID, accessKey)
 973         c.Assert(err, IsNil)
 974
 975         err = client.CreateBucket(bucketNameTest)
 976         c.Assert(err, IsNil)
 977
 978         deleteMark := true
 979         expiration := LifecycleExpiration{
 980                 ExpiredObjectDeleteMarker: &deleteMark,
 981         }
 982
 983         versionExpiration := LifecycleVersionExpiration{
 984                 NoncurrentDays: 20,
 985         }
 986
 987         versionTransition := LifecycleVersionTransition{
 988                 NoncurrentDays: 10,
 989                 StorageClass:   "IA",
 990         }
 991
 992         rule := LifecycleRule{
 993                 Status:               "Enabled",
 994                 Expiration:           &expiration,
 995                 NonVersionExpiration: &versionExpiration,
 996                 NonVersionTransition: &versionTransition,
 997         }
 998         rules := []LifecycleRule{rule}
 999
1000         err = client.SetBucketLifecycle(bucketNameTest, rules)
1001         c.Assert(err, IsNil)
1002
1003         res, err := client.GetBucketLifecycle(bucketNameTest)
1004         c.Assert(err, IsNil)
1005
1006         c.Assert(res.Rules[0].Expiration, NotNil)
1007         c.Assert(res.Rules[0].Expiration.Days, Equals, 0)
1008         c.Assert(res.Rules[0].Expiration.Date, Equals, "")
1009         c.Assert(*(res.Rules[0].Expiration.ExpiredObjectDeleteMarker), Equals, true)
1010
1011         c.Assert(res.Rules[0].NonVersionExpiration.NoncurrentDays, Equals, 20)
1012         c.Assert(res.Rules[0].NonVersionTransition.NoncurrentDays, Equals, 10)
1013         c.Assert(res.Rules[0].NonVersionTransition.StorageClass, Equals, StorageClassType("IA"))
1014
1015         err = client.DeleteBucket(bucketNameTest)
1016         c.Assert(err, IsNil)
1017 }
1018
1019 // TestSetBucketLifecycleAboutVersionObject
1020 func (s *OssClientSuite) TestSetBucketLifecycleAboutVersionObjectError(c *C) {
1021         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1022
1023         client, err := New(endpoint, accessID, accessKey)
1024         c.Assert(err, IsNil)
1025
1026         err = client.CreateBucket(bucketNameTest)
1027         c.Assert(err, IsNil)
1028
1029         deleteMark := true
1030         expiration := LifecycleExpiration{
1031                 ExpiredObjectDeleteMarker: &deleteMark,
1032         }
1033
1034         versionExpiration := LifecycleVersionExpiration{
1035                 NoncurrentDays: 20,
1036         }
1037
1038         versionTransition := LifecycleVersionTransition{
1039                 NoncurrentDays: 10,
1040                 StorageClass:   "IA",
1041         }
1042
1043         // NonVersionTransition and NonVersionTransitions can not both have value
1044         rule := LifecycleRule{
1045                 Status:                "Enabled",
1046                 Expiration:            &expiration,
1047                 NonVersionExpiration:  &versionExpiration,
1048                 NonVersionTransition:  &versionTransition,
1049                 NonVersionTransitions: []LifecycleVersionTransition{versionTransition},
1050         }
1051         rules := []LifecycleRule{rule}
1052
1053         err = client.SetBucketLifecycle(bucketNameTest, rules)
1054         c.Assert(err, NotNil)
1055
1056         err = client.DeleteBucket(bucketNameTest)
1057         c.Assert(err, IsNil)
1058 }
1059
1060 // TestSetBucketLifecycleAboutVersionObject
1061 func (s *OssClientSuite) TestSetBucketLifecycleAboutVersionObjectNew(c *C) {
1062         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1063
1064         client, err := New(endpoint, accessID, accessKey)
1065         c.Assert(err, IsNil)
1066
1067         err = client.CreateBucket(bucketNameTest)
1068         c.Assert(err, IsNil)
1069
1070         deleteMark := true
1071         expiration := LifecycleExpiration{
1072                 ExpiredObjectDeleteMarker: &deleteMark,
1073         }
1074
1075         versionExpiration := LifecycleVersionExpiration{
1076                 NoncurrentDays: 40,
1077         }
1078
1079         versionTransition1 := LifecycleVersionTransition{
1080                 NoncurrentDays: 25,
1081                 StorageClass:   "IA",
1082         }
1083
1084         versionTransition2 := LifecycleVersionTransition{
1085                 NoncurrentDays: 30,
1086                 StorageClass:   "ColdArchive",
1087         }
1088
1089         rule := LifecycleRule{
1090                 Status:                "Enabled",
1091                 Expiration:            &expiration,
1092                 NonVersionExpiration:  &versionExpiration,
1093                 NonVersionTransitions: []LifecycleVersionTransition{versionTransition1, versionTransition2},
1094         }
1095         rules := []LifecycleRule{rule}
1096
1097         err = client.SetBucketLifecycle(bucketNameTest, rules)
1098         c.Assert(err, IsNil)
1099
1100         res, err := client.GetBucketLifecycle(bucketNameTest)
1101         c.Assert(err, IsNil)
1102
1103         c.Assert(res.Rules[0].Expiration, NotNil)
1104         c.Assert(res.Rules[0].Expiration.Days, Equals, 0)
1105         c.Assert(res.Rules[0].Expiration.Date, Equals, "")
1106         c.Assert(*(res.Rules[0].Expiration.ExpiredObjectDeleteMarker), Equals, true)
1107
1108         c.Assert(res.Rules[0].NonVersionExpiration.NoncurrentDays, Equals, 40)
1109         c.Assert(res.Rules[0].NonVersionTransition.NoncurrentDays, Equals, 25)
1110         c.Assert(res.Rules[0].NonVersionTransition.StorageClass, Equals, StorageClassType("IA"))
1111         c.Assert(len(res.Rules[0].NonVersionTransitions), Equals, 2)
1112
1113         err = client.DeleteBucket(bucketNameTest)
1114         c.Assert(err, IsNil)
1115 }
1116
1117 // TestDeleteBucketLifecycle
1118 func (s *OssClientSuite) TestDeleteBucketLifecycle(c *C) {
1119         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1120
1121         var rule1 = BuildLifecycleRuleByDate("rule1", "one", true, 2015, 11, 11)
1122         var rule2 = BuildLifecycleRuleByDays("rule2", "two", true, 3)
1123         var rules = []LifecycleRule{rule1, rule2}
1124
1125         client, err := New(endpoint, accessID, accessKey)
1126         c.Assert(err, IsNil)
1127
1128         err = client.CreateBucket(bucketNameTest)
1129         c.Assert(err, IsNil)
1130         //time.Sleep(timeoutInOperation)
1131
1132         err = client.DeleteBucketLifecycle(bucketNameTest)
1133         c.Assert(err, IsNil)
1134
1135         err = client.SetBucketLifecycle(bucketNameTest, rules)
1136         c.Assert(err, IsNil)
1137         //time.Sleep(timeoutInOperation)
1138
1139         res, err := client.GetBucketLifecycle(bucketNameTest)
1140         c.Assert(err, IsNil)
1141         c.Assert(len(res.Rules), Equals, 2)
1142
1143         // Delete
1144         err = client.DeleteBucketLifecycle(bucketNameTest)
1145         c.Assert(err, IsNil)
1146
1147         //time.Sleep(timeoutInOperation)
1148         res, err = client.GetBucketLifecycle(bucketNameTest)
1149         c.Assert(err, NotNil)
1150
1151         // Eliminate effect of cache
1152         //time.Sleep(timeoutInOperation)
1153
1154         // Delete when not set
1155         err = client.DeleteBucketLifecycle(bucketNameTest)
1156         c.Assert(err, IsNil)
1157
1158         err = client.DeleteBucket(bucketNameTest)
1159         c.Assert(err, IsNil)
1160 }
1161
1162 // TestSetBucketLifecycleNegative
1163 func (s *OssClientSuite) TestBucketLifecycleNegative(c *C) {
1164         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1165         var rules = []LifecycleRule{}
1166
1167         client, err := New(endpoint, accessID, accessKey)
1168         c.Assert(err, IsNil)
1169
1170         err = client.CreateBucket(bucketNameTest)
1171         c.Assert(err, IsNil)
1172
1173         // Set with no rule
1174         err = client.SetBucketLifecycle(bucketNameTest, rules)
1175         c.Assert(err, NotNil)
1176
1177         err = client.DeleteBucket(bucketNameTest)
1178         c.Assert(err, IsNil)
1179
1180         // Not exist
1181         err = client.SetBucketLifecycle(bucketNameTest, rules)
1182         c.Assert(err, NotNil)
1183
1184         // Not exist
1185         _, err = client.GetBucketLifecycle(bucketNameTest)
1186         c.Assert(err, NotNil)
1187
1188         // Not exist
1189         err = client.DeleteBucketLifecycle(bucketNameTest)
1190         c.Assert(err, NotNil)
1191 }
1192
1193 // TestSetBucketReferer
1194 func (s *OssClientSuite) TestSetBucketReferer(c *C) {
1195         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1196         var referers = []string{"http://www.aliyun.com", "https://www.aliyun.com"}
1197
1198         client, err := New(endpoint, accessID, accessKey)
1199         c.Assert(err, IsNil)
1200
1201         err = client.CreateBucket(bucketNameTest)
1202         c.Assert(err, IsNil)
1203         time.Sleep(timeoutInOperation)
1204
1205         res, err := client.GetBucketReferer(bucketNameTest)
1206         c.Assert(res.AllowEmptyReferer, Equals, true)
1207         c.Assert(len(res.RefererList), Equals, 0)
1208
1209         // Set referers
1210         err = client.SetBucketReferer(bucketNameTest, referers, false)
1211         c.Assert(err, IsNil)
1212         time.Sleep(timeoutInOperation)
1213
1214         res, err = client.GetBucketReferer(bucketNameTest)
1215         c.Assert(res.AllowEmptyReferer, Equals, false)
1216         c.Assert(len(res.RefererList), Equals, 2)
1217         c.Assert(res.RefererList[0], Equals, "http://www.aliyun.com")
1218         c.Assert(res.RefererList[1], Equals, "https://www.aliyun.com")
1219
1220         // Reset referer, referers empty
1221         referers = []string{""}
1222         err = client.SetBucketReferer(bucketNameTest, referers, true)
1223         c.Assert(err, IsNil)
1224
1225         referers = []string{}
1226         err = client.SetBucketReferer(bucketNameTest, referers, true)
1227         c.Assert(err, IsNil)
1228
1229         res, err = client.GetBucketReferer(bucketNameTest)
1230         c.Assert(res.AllowEmptyReferer, Equals, true)
1231         c.Assert(len(res.RefererList), Equals, 0)
1232
1233         err = client.DeleteBucket(bucketNameTest)
1234         c.Assert(err, IsNil)
1235 }
1236
1237 // TestSetBucketRefererNegative
1238 func (s *OssClientSuite) TestBucketRefererNegative(c *C) {
1239         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1240         var referers = []string{""}
1241
1242         client, err := New(endpoint, accessID, accessKey)
1243         c.Assert(err, IsNil)
1244
1245         // Not exist
1246         _, err = client.GetBucketReferer(bucketNameTest)
1247         c.Assert(err, NotNil)
1248         testLogger.Println(err)
1249
1250         // Not exist
1251         err = client.SetBucketReferer(bucketNameTest, referers, true)
1252         c.Assert(err, NotNil)
1253         testLogger.Println(err)
1254 }
1255
1256 // TestSetBucketLogging
1257 func (s *OssClientSuite) TestSetBucketLogging(c *C) {
1258         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1259         var bucketNameTarget = bucketNameTest + "-target"
1260
1261         client, err := New(endpoint, accessID, accessKey)
1262         c.Assert(err, IsNil)
1263
1264         err = client.CreateBucket(bucketNameTest)
1265         c.Assert(err, IsNil)
1266         err = client.CreateBucket(bucketNameTarget)
1267         c.Assert(err, IsNil)
1268         time.Sleep(timeoutInOperation)
1269
1270         // Set logging
1271         err = client.SetBucketLogging(bucketNameTest, bucketNameTarget, "prefix", true)
1272         c.Assert(err, IsNil)
1273         // Reset
1274         err = client.SetBucketLogging(bucketNameTest, bucketNameTarget, "prefix", false)
1275         c.Assert(err, IsNil)
1276
1277         time.Sleep(timeoutInOperation)
1278         res, err := client.GetBucketLogging(bucketNameTest)
1279         c.Assert(err, IsNil)
1280         c.Assert(res.LoggingEnabled.TargetBucket, Equals, "")
1281         c.Assert(res.LoggingEnabled.TargetPrefix, Equals, "")
1282
1283         err = client.DeleteBucketLogging(bucketNameTest)
1284         c.Assert(err, IsNil)
1285
1286         // Set to self
1287         err = client.SetBucketLogging(bucketNameTest, bucketNameTest, "prefix", true)
1288         c.Assert(err, IsNil)
1289
1290         err = client.DeleteBucket(bucketNameTest)
1291         c.Assert(err, IsNil)
1292         err = client.DeleteBucket(bucketNameTarget)
1293         c.Assert(err, IsNil)
1294 }
1295
1296 // TestDeleteBucketLogging
1297 func (s *OssClientSuite) TestDeleteBucketLogging(c *C) {
1298         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1299         var bucketNameTarget = bucketNameTest + "-target"
1300
1301         client, err := New(endpoint, accessID, accessKey)
1302         c.Assert(err, IsNil)
1303
1304         err = client.CreateBucket(bucketNameTest)
1305         c.Assert(err, IsNil)
1306         err = client.CreateBucket(bucketNameTarget)
1307         c.Assert(err, IsNil)
1308         time.Sleep(timeoutInOperation)
1309
1310         // Get when not set
1311         res, err := client.GetBucketLogging(bucketNameTest)
1312         c.Assert(err, IsNil)
1313         c.Assert(res.LoggingEnabled.TargetBucket, Equals, "")
1314         c.Assert(res.LoggingEnabled.TargetPrefix, Equals, "")
1315
1316         // Set
1317         err = client.SetBucketLogging(bucketNameTest, bucketNameTarget, "prefix", true)
1318         c.Assert(err, IsNil)
1319
1320         // Get
1321         time.Sleep(timeoutInOperation)
1322         res, err = client.GetBucketLogging(bucketNameTest)
1323         c.Assert(err, IsNil)
1324         c.Assert(res.LoggingEnabled.TargetBucket, Equals, bucketNameTarget)
1325         c.Assert(res.LoggingEnabled.TargetPrefix, Equals, "prefix")
1326
1327         // Set
1328         err = client.SetBucketLogging(bucketNameTest, bucketNameTarget, "prefix", false)
1329         c.Assert(err, IsNil)
1330
1331         // Get
1332         time.Sleep(timeoutInOperation)
1333         res, err = client.GetBucketLogging(bucketNameTest)
1334         c.Assert(err, IsNil)
1335         c.Assert(res.LoggingEnabled.TargetBucket, Equals, "")
1336         c.Assert(res.LoggingEnabled.TargetPrefix, Equals, "")
1337
1338         // Delete
1339         err = client.DeleteBucketLogging(bucketNameTest)
1340         c.Assert(err, IsNil)
1341
1342         // Get after delete
1343         time.Sleep(timeoutInOperation)
1344         res, err = client.GetBucketLogging(bucketNameTest)
1345         c.Assert(err, IsNil)
1346         c.Assert(res.LoggingEnabled.TargetBucket, Equals, "")
1347         c.Assert(res.LoggingEnabled.TargetPrefix, Equals, "")
1348
1349         err = client.DeleteBucket(bucketNameTest)
1350         c.Assert(err, IsNil)
1351         err = client.DeleteBucket(bucketNameTarget)
1352         c.Assert(err, IsNil)
1353 }
1354
1355 // TestSetBucketLoggingNegative
1356 func (s *OssClientSuite) TestSetBucketLoggingNegative(c *C) {
1357         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1358         var bucketNameTarget = bucketNameTest + "-target"
1359
1360         client, err := New(endpoint, accessID, accessKey)
1361         c.Assert(err, IsNil)
1362
1363         // Not exist
1364         _, err = client.GetBucketLogging(bucketNameTest)
1365         c.Assert(err, NotNil)
1366
1367         // Not exist
1368         err = client.SetBucketLogging(bucketNameTest, "targetbucket", "prefix", true)
1369         c.Assert(err, NotNil)
1370
1371         // Not exist
1372         err = client.DeleteBucketLogging(bucketNameTest)
1373         c.Assert(err, NotNil)
1374
1375         err = client.CreateBucket(bucketNameTest)
1376         c.Assert(err, IsNil)
1377         time.Sleep(timeoutInOperation)
1378
1379         // Target bucket not exist
1380         err = client.SetBucketLogging(bucketNameTest, bucketNameTarget, "prefix", true)
1381         c.Assert(err, NotNil)
1382
1383         // Parameter invalid
1384         err = client.SetBucketLogging(bucketNameTest, "XXXX", "prefix", true)
1385         c.Assert(err, NotNil)
1386
1387         err = client.SetBucketLogging(bucketNameTest, "xx", "prefix", true)
1388         c.Assert(err, NotNil)
1389
1390         err = client.DeleteBucket(bucketNameTest)
1391         c.Assert(err, IsNil)
1392 }
1393
1394 // TestSetBucketWebsite
1395 func (s *OssClientSuite) TestSetBucketWebsite(c *C) {
1396         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1397         var indexWebsite = "myindex.html"
1398         var errorWebsite = "myerror.html"
1399
1400         client, err := New(endpoint, accessID, accessKey)
1401         c.Assert(err, IsNil)
1402         time.Sleep(timeoutInOperation)
1403
1404         err = client.CreateBucket(bucketNameTest)
1405         c.Assert(err, IsNil)
1406
1407         // Set
1408         err = client.SetBucketWebsite(bucketNameTest, indexWebsite, errorWebsite)
1409         c.Assert(err, IsNil)
1410
1411         // Double set
1412         err = client.SetBucketWebsite(bucketNameTest, indexWebsite, errorWebsite)
1413         c.Assert(err, IsNil)
1414
1415         res, err := client.GetBucketWebsite(bucketNameTest)
1416         c.Assert(err, IsNil)
1417         c.Assert(res.IndexDocument.Suffix, Equals, indexWebsite)
1418         c.Assert(res.ErrorDocument.Key, Equals, errorWebsite)
1419
1420         // Reset
1421         err = client.SetBucketWebsite(bucketNameTest, "your"+indexWebsite, "your"+errorWebsite)
1422         c.Assert(err, IsNil)
1423
1424         time.Sleep(timeoutInOperation)
1425         res, err = client.GetBucketWebsite(bucketNameTest)
1426         c.Assert(err, IsNil)
1427         c.Assert(res.IndexDocument.Suffix, Equals, "your"+indexWebsite)
1428         c.Assert(res.ErrorDocument.Key, Equals, "your"+errorWebsite)
1429
1430         err = client.DeleteBucketWebsite(bucketNameTest)
1431         c.Assert(err, IsNil)
1432
1433         // Set after delete
1434         err = client.SetBucketWebsite(bucketNameTest, indexWebsite, errorWebsite)
1435         c.Assert(err, IsNil)
1436
1437         // Eliminate effect of cache
1438         time.Sleep(timeoutInOperation)
1439
1440         res, err = client.GetBucketWebsite(bucketNameTest)
1441         c.Assert(err, IsNil)
1442         c.Assert(res.IndexDocument.Suffix, Equals, indexWebsite)
1443         c.Assert(res.ErrorDocument.Key, Equals, errorWebsite)
1444
1445         err = client.DeleteBucket(bucketNameTest)
1446         c.Assert(err, IsNil)
1447 }
1448
1449 // TestDeleteBucketWebsite
1450 func (s *OssClientSuite) TestDeleteBucketWebsite(c *C) {
1451         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1452         var indexWebsite = "myindex.html"
1453         var errorWebsite = "myerror.html"
1454
1455         client, err := New(endpoint, accessID, accessKey)
1456         c.Assert(err, IsNil)
1457
1458         err = client.CreateBucket(bucketNameTest)
1459         c.Assert(err, IsNil)
1460         time.Sleep(timeoutInOperation)
1461
1462         // Get
1463         res, err := client.GetBucketWebsite(bucketNameTest)
1464         c.Assert(err, NotNil)
1465
1466         // Detele without set
1467         err = client.DeleteBucketWebsite(bucketNameTest)
1468         c.Assert(err, IsNil)
1469
1470         // Set
1471         err = client.SetBucketWebsite(bucketNameTest, indexWebsite, errorWebsite)
1472         c.Assert(err, IsNil)
1473
1474         time.Sleep(timeoutInOperation)
1475         res, err = client.GetBucketWebsite(bucketNameTest)
1476         c.Assert(err, IsNil)
1477         c.Assert(res.IndexDocument.Suffix, Equals, indexWebsite)
1478         c.Assert(res.ErrorDocument.Key, Equals, errorWebsite)
1479
1480         // Detele
1481         time.Sleep(timeoutInOperation)
1482         err = client.DeleteBucketWebsite(bucketNameTest)
1483         c.Assert(err, IsNil)
1484
1485         time.Sleep(timeoutInOperation)
1486         res, err = client.GetBucketWebsite(bucketNameTest)
1487         c.Assert(err, NotNil)
1488
1489         // Detele after delete
1490         err = client.DeleteBucketWebsite(bucketNameTest)
1491         c.Assert(err, IsNil)
1492
1493         err = client.DeleteBucket(bucketNameTest)
1494         c.Assert(err, IsNil)
1495 }
1496
1497 // TestSetBucketWebsiteNegative
1498 func (s *OssClientSuite) TestSetBucketWebsiteNegative(c *C) {
1499         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1500         var indexWebsite = "myindex.html"
1501         var errorWebsite = "myerror.html"
1502
1503         client, err := New(endpoint, accessID, accessKey)
1504         c.Assert(err, IsNil)
1505
1506         err = client.DeleteBucket(bucketNameTest)
1507
1508         // Not exist
1509         _, err = client.GetBucketWebsite(bucketNameTest)
1510         c.Assert(err, NotNil)
1511
1512         err = client.DeleteBucketWebsite(bucketNameTest)
1513         c.Assert(err, NotNil)
1514
1515         err = client.SetBucketWebsite(bucketNameTest, indexWebsite, errorWebsite)
1516         c.Assert(err, NotNil)
1517
1518         err = client.CreateBucket(bucketNameTest)
1519         c.Assert(err, IsNil)
1520
1521         // Set
1522         time.Sleep(timeoutInOperation)
1523         err = client.SetBucketWebsite(bucketNameTest, "myindex", "myerror")
1524         c.Assert(err, IsNil)
1525
1526         res, err := client.GetBucketWebsite(bucketNameTest)
1527         c.Assert(err, IsNil)
1528         c.Assert(res.IndexDocument.Suffix, Equals, "myindex")
1529         c.Assert(res.ErrorDocument.Key, Equals, "myerror")
1530
1531         // Detele
1532         err = client.DeleteBucketWebsite(bucketNameTest)
1533         c.Assert(err, IsNil)
1534
1535         time.Sleep(timeoutInOperation)
1536         _, err = client.GetBucketWebsite(bucketNameTest)
1537         c.Assert(err, NotNil)
1538
1539         // Detele after delete
1540         err = client.DeleteBucketWebsite(bucketNameTest)
1541         c.Assert(err, IsNil)
1542
1543         err = client.DeleteBucket(bucketNameTest)
1544         c.Assert(err, IsNil)
1545 }
1546
1547 // TestSetBucketWebsiteDetail
1548 func (s *OssClientSuite) TestSetBucketWebsiteDetail(c *C) {
1549         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1550         var indexWebsite = "myindex.html"
1551         var errorWebsite = "myerror.html"
1552
1553         client, err := New(endpoint, accessID, accessKey)
1554         c.Assert(err, IsNil)
1555
1556         err = client.CreateBucket(bucketNameTest)
1557         c.Assert(err, IsNil)
1558         time.Sleep(timeoutInOperation)
1559
1560         btrue := true
1561         bfalse := false
1562         // Define one routing rule
1563         ruleOk := RoutingRule{
1564                 RuleNumber: 1,
1565                 Condition: Condition{
1566                         KeyPrefixEquals:             "",
1567                         HTTPErrorCodeReturnedEquals: 404,
1568                 },
1569                 Redirect: Redirect{
1570                         RedirectType: "Mirror",
1571                         // PassQueryString: &btrue,             // set default value
1572                         MirrorURL: "http://www.test.com/",
1573                         // MirrorPassQueryString:&btrue,        // set default value
1574                         // MirrorFollowRedirect:&bfalse,        // set default value
1575                         // MirrorCheckMd5:&bfalse,                      // set default value
1576                         MirrorHeaders: MirrorHeaders{
1577                                 // PassAll:&bfalse,                     // set default value
1578                                 Pass:   []string{"myheader-key1", "myheader-key2"},
1579                                 Remove: []string{"myheader-key3", "myheader-key4"},
1580                                 Set: []MirrorHeaderSet{
1581                                         MirrorHeaderSet{
1582                                                 Key:   "myheader-key5",
1583                                                 Value: "myheader-value5",
1584                                         },
1585                                 },
1586                         },
1587                 },
1588         }
1589
1590         // Define array routing rule
1591         ruleArrOk := []RoutingRule{
1592                 RoutingRule{
1593                         RuleNumber: 2,
1594                         Condition: Condition{
1595                                 KeyPrefixEquals:             "abc/",
1596                                 HTTPErrorCodeReturnedEquals: 404,
1597                                 IncludeHeader: []IncludeHeader{
1598                                         IncludeHeader{
1599                                                 Key:    "host",
1600                                                 Equals: "test.oss-cn-beijing-internal.aliyuncs.com",
1601                                         },
1602                                 },
1603                         },
1604                         Redirect: Redirect{
1605                                 RedirectType:     "AliCDN",
1606                                 Protocol:         "http",
1607                                 HostName:         "www.test.com",
1608                                 PassQueryString:  &bfalse,
1609                                 ReplaceKeyWith:   "prefix/${key}.suffix",
1610                                 HttpRedirectCode: 301,
1611                         },
1612                 },
1613                 RoutingRule{
1614                         RuleNumber: 3,
1615                         Condition: Condition{
1616                                 KeyPrefixEquals:             "",
1617                                 HTTPErrorCodeReturnedEquals: 404,
1618                         },
1619                         Redirect: Redirect{
1620                                 RedirectType:          "Mirror",
1621                                 PassQueryString:       &btrue,
1622                                 MirrorURL:             "http://www.test.com/",
1623                                 MirrorPassQueryString: &btrue,
1624                                 MirrorFollowRedirect:  &bfalse,
1625                                 MirrorCheckMd5:        &bfalse,
1626                                 MirrorHeaders: MirrorHeaders{
1627                                         PassAll: &btrue,
1628                                         Pass:    []string{"myheader-key1", "myheader-key2"},
1629                                         Remove:  []string{"myheader-key3", "myheader-key4"},
1630                                         Set: []MirrorHeaderSet{
1631                                                 MirrorHeaderSet{
1632                                                         Key:   "myheader-key5",
1633                                                         Value: "myheader-value5",
1634                                                 },
1635                                         },
1636                                 },
1637                         },
1638                 },
1639         }
1640
1641         // Set one routing rule
1642         wxmlOne := WebsiteXML{}
1643         wxmlOne.RoutingRules = append(wxmlOne.RoutingRules, ruleOk)
1644         var responseHeader http.Header
1645         err = client.SetBucketWebsiteDetail(bucketNameTest, wxmlOne, GetResponseHeader(&responseHeader))
1646         c.Assert(err, IsNil)
1647         requestId := GetRequestId(responseHeader)
1648         c.Assert(len(requestId) > 0, Equals, true)
1649
1650         res, err := client.GetBucketWebsite(bucketNameTest)
1651         c.Assert(err, IsNil)
1652         c.Assert(res.RoutingRules[0].Redirect.RedirectType, Equals, "Mirror")
1653         c.Assert(*res.RoutingRules[0].Redirect.PassQueryString, Equals, false)
1654         c.Assert(*res.RoutingRules[0].Redirect.MirrorPassQueryString, Equals, false)
1655         c.Assert(*res.RoutingRules[0].Redirect.MirrorFollowRedirect, Equals, true)
1656         c.Assert(*res.RoutingRules[0].Redirect.MirrorCheckMd5, Equals, false)
1657         c.Assert(*res.RoutingRules[0].Redirect.MirrorHeaders.PassAll, Equals, false)
1658
1659         // Set one routing rule and IndexDocument, IndexDocument
1660         wxml := WebsiteXML{
1661                 IndexDocument: IndexDocument{Suffix: indexWebsite},
1662                 ErrorDocument: ErrorDocument{Key: errorWebsite},
1663         }
1664         wxml.RoutingRules = append(wxml.RoutingRules, ruleOk)
1665         err = client.SetBucketWebsiteDetail(bucketNameTest, wxml, GetResponseHeader(&responseHeader))
1666         c.Assert(err, IsNil)
1667         requestId = GetRequestId(responseHeader)
1668         c.Assert(len(requestId) > 0, Equals, true)
1669
1670         res, err = client.GetBucketWebsite(bucketNameTest)
1671         c.Assert(err, IsNil)
1672         c.Assert(res.IndexDocument.Suffix, Equals, indexWebsite)
1673         c.Assert(res.ErrorDocument.Key, Equals, errorWebsite)
1674         c.Assert(res.RoutingRules[0].Redirect.RedirectType, Equals, "Mirror")
1675
1676         // Set array routing rule
1677         wxml.RoutingRules = append(wxml.RoutingRules, ruleArrOk...)
1678         err = client.SetBucketWebsiteDetail(bucketNameTest, wxml, GetResponseHeader(&responseHeader))
1679         c.Assert(err, IsNil)
1680         requestId = GetRequestId(responseHeader)
1681         c.Assert(len(requestId) > 0, Equals, true)
1682
1683         res, err = client.GetBucketWebsite(bucketNameTest)
1684         c.Assert(err, IsNil)
1685         c.Assert(res.IndexDocument.Suffix, Equals, indexWebsite)
1686         c.Assert(res.ErrorDocument.Key, Equals, errorWebsite)
1687         c.Assert(len(res.RoutingRules), Equals, 3)
1688         c.Assert(res.RoutingRules[1].Redirect.RedirectType, Equals, "AliCDN")
1689         c.Assert(*res.RoutingRules[2].Redirect.MirrorPassQueryString, Equals, true)
1690         c.Assert(*res.RoutingRules[2].Redirect.MirrorFollowRedirect, Equals, false)
1691
1692         // Define one error routing rule
1693         ruleErr := RoutingRule{
1694                 RuleNumber: 1,
1695                 Redirect: Redirect{
1696                         RedirectType:    "Mirror",
1697                         PassQueryString: &btrue,
1698                 },
1699         }
1700         // Define array error routing rule
1701         rulesErrArr := []RoutingRule{
1702                 RoutingRule{
1703                         RuleNumber: 1,
1704                         Redirect: Redirect{
1705                                 RedirectType:    "Mirror",
1706                                 PassQueryString: &btrue,
1707                         },
1708                 },
1709                 RoutingRule{
1710                         RuleNumber: 2,
1711                         Redirect: Redirect{
1712                                 RedirectType:    "Mirror",
1713                                 PassQueryString: &btrue,
1714                         },
1715                 },
1716         }
1717
1718         ruleIntErr := RoutingRule{
1719                 // RuleNumber:0,                                                // set NULL value
1720                 Condition: Condition{
1721                         KeyPrefixEquals:             "",
1722                         HTTPErrorCodeReturnedEquals: 404,
1723                 },
1724                 Redirect: Redirect{
1725                         RedirectType: "Mirror",
1726                         // PassQueryString: &btrue,             // set default value
1727                         MirrorURL: "http://www.test.com/",
1728                         // MirrorPassQueryString:&btrue,        // set default value
1729                         // MirrorFollowRedirect:&bfalse,        // set default value
1730                         // MirrorCheckMd5:&bfalse,                      // set default value
1731                         MirrorHeaders: MirrorHeaders{
1732                                 // PassAll:&bfalse,                     // set default value
1733                                 Pass:   []string{"myheader-key1", "myheader-key2"},
1734                                 Remove: []string{"myheader-key3", "myheader-key4"},
1735                                 Set: []MirrorHeaderSet{
1736                                         MirrorHeaderSet{
1737                                                 Key:   "myheader-key5",
1738                                                 Value: "myheader-value5",
1739                                         },
1740                                 },
1741                         },
1742                 },
1743         }
1744
1745         // Set one int type error rule
1746         wxmlIntErr := WebsiteXML{}
1747         wxmlIntErr.RoutingRules = append(wxmlIntErr.RoutingRules, ruleIntErr)
1748         err = client.SetBucketWebsiteDetail(bucketNameTest, wxmlIntErr)
1749         c.Assert(err, NotNil)
1750
1751         // Set one error rule
1752         wxmlErr := WebsiteXML{}
1753         wxmlErr.RoutingRules = append(wxmlErr.RoutingRules, ruleErr)
1754         err = client.SetBucketWebsiteDetail(bucketNameTest, wxmlErr)
1755         c.Assert(err, NotNil)
1756
1757         // Set one error rule and one correct rule
1758         wxmlErr.RoutingRules = append(wxmlErr.RoutingRules, ruleOk)
1759         err = client.SetBucketWebsiteDetail(bucketNameTest, wxmlErr)
1760         c.Assert(err, NotNil)
1761
1762         wxmlErrRuleArr := WebsiteXML{}
1763         wxmlErrRuleArr.RoutingRules = append(wxmlErrRuleArr.RoutingRules, rulesErrArr...)
1764         // Set array error routing rule
1765         err = client.SetBucketWebsiteDetail(bucketNameTest, wxmlErrRuleArr)
1766         c.Assert(err, NotNil)
1767
1768         err = client.DeleteBucketWebsite(bucketNameTest)
1769         c.Assert(err, IsNil)
1770
1771         err = client.DeleteBucket(bucketNameTest)
1772         c.Assert(err, IsNil)
1773 }
1774
1775 // TestSetBucketWebsiteXml
1776 func (s *OssClientSuite) TestSetBucketWebsiteXml(c *C) {
1777         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1778         client, err := New(endpoint, accessID, accessKey)
1779         c.Assert(err, IsNil)
1780
1781         err = client.CreateBucket(bucketNameTest)
1782         c.Assert(err, IsNil)
1783         time.Sleep(timeoutInOperation)
1784
1785         // Define one routing rule
1786         ruleOk := RoutingRule{
1787                 RuleNumber: 1,
1788                 Condition: Condition{
1789                         KeyPrefixEquals:             "",
1790                         HTTPErrorCodeReturnedEquals: 404,
1791                 },
1792                 Redirect: Redirect{
1793                         RedirectType: "Mirror",
1794                         // PassQueryString: &btrue,             // set default value
1795                         MirrorURL: "http://www.test.com/",
1796                         // MirrorPassQueryString:&btrue,        // set default value
1797                         // MirrorFollowRedirect:&bfalse,        // set default value
1798                         // MirrorCheckMd5:&bfalse,                      // set default value
1799                         MirrorHeaders: MirrorHeaders{
1800                                 // PassAll:&bfalse,                     // set default value
1801                                 Pass:   []string{"myheader-key1", "myheader-key2"},
1802                                 Remove: []string{"myheader-key3", "myheader-key4"},
1803                                 Set: []MirrorHeaderSet{
1804                                         MirrorHeaderSet{
1805                                                 Key:   "myheader-key5",
1806                                                 Value: "myheader-value5",
1807                                         },
1808                                 },
1809                         },
1810                 },
1811         }
1812
1813         // Set one routing rule
1814         wxmlOne := WebsiteXML{}
1815         wxmlOne.RoutingRules = append(wxmlOne.RoutingRules, ruleOk)
1816         bs, err := xml.Marshal(wxmlOne)
1817         c.Assert(err, IsNil)
1818
1819         var responseHeader http.Header
1820         err = client.SetBucketWebsiteXml(bucketNameTest, string(bs), GetResponseHeader(&responseHeader))
1821         c.Assert(err, IsNil)
1822
1823         requestId := GetRequestId(responseHeader)
1824         c.Assert(len(requestId) > 0, Equals, true)
1825
1826         res, err := client.GetBucketWebsite(bucketNameTest)
1827         c.Assert(err, IsNil)
1828         c.Assert(res.RoutingRules[0].Redirect.RedirectType, Equals, "Mirror")
1829         c.Assert(*res.RoutingRules[0].Redirect.PassQueryString, Equals, false)
1830         c.Assert(*res.RoutingRules[0].Redirect.MirrorPassQueryString, Equals, false)
1831         c.Assert(*res.RoutingRules[0].Redirect.MirrorFollowRedirect, Equals, true)
1832         c.Assert(*res.RoutingRules[0].Redirect.MirrorCheckMd5, Equals, false)
1833         c.Assert(*res.RoutingRules[0].Redirect.MirrorHeaders.PassAll, Equals, false)
1834 }
1835
1836 // TestSetBucketCORS
1837 func (s *OssClientSuite) TestSetBucketCORS(c *C) {
1838         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1839         var rule1 = CORSRule{
1840                 AllowedOrigin: []string{"*"},
1841                 AllowedMethod: []string{"PUT", "GET", "POST"},
1842                 AllowedHeader: []string{},
1843                 ExposeHeader:  []string{},
1844                 MaxAgeSeconds: 100,
1845         }
1846
1847         var rule2 = CORSRule{
1848                 AllowedOrigin: []string{"http://www.a.com", "http://www.b.com"},
1849                 AllowedMethod: []string{"GET"},
1850                 AllowedHeader: []string{"Authorization"},
1851                 ExposeHeader:  []string{"x-oss-test", "x-oss-test1"},
1852                 MaxAgeSeconds: 200,
1853         }
1854
1855         client, err := New(endpoint, accessID, accessKey)
1856         c.Assert(err, IsNil)
1857
1858         err = client.CreateBucket(bucketNameTest)
1859         c.Assert(err, IsNil)
1860         time.Sleep(timeoutInOperation)
1861
1862         // Set
1863         err = client.SetBucketCORS(bucketNameTest, []CORSRule{rule1})
1864         c.Assert(err, IsNil)
1865
1866         gbcr, err := client.GetBucketCORS(bucketNameTest)
1867         c.Assert(err, IsNil)
1868         c.Assert(len(gbcr.CORSRules), Equals, 1)
1869         c.Assert(len(gbcr.CORSRules[0].AllowedOrigin), Equals, 1)
1870         c.Assert(len(gbcr.CORSRules[0].AllowedMethod), Equals, 3)
1871         c.Assert(len(gbcr.CORSRules[0].AllowedHeader), Equals, 0)
1872         c.Assert(len(gbcr.CORSRules[0].ExposeHeader), Equals, 0)
1873         c.Assert(gbcr.CORSRules[0].MaxAgeSeconds, Equals, 100)
1874
1875         // Double set
1876         err = client.SetBucketCORS(bucketNameTest, []CORSRule{rule1})
1877         c.Assert(err, IsNil)
1878
1879         gbcr, err = client.GetBucketCORS(bucketNameTest)
1880         c.Assert(err, IsNil)
1881         c.Assert(len(gbcr.CORSRules), Equals, 1)
1882         c.Assert(len(gbcr.CORSRules[0].AllowedOrigin), Equals, 1)
1883         c.Assert(len(gbcr.CORSRules[0].AllowedMethod), Equals, 3)
1884         c.Assert(len(gbcr.CORSRules[0].AllowedHeader), Equals, 0)
1885         c.Assert(len(gbcr.CORSRules[0].ExposeHeader), Equals, 0)
1886         c.Assert(gbcr.CORSRules[0].MaxAgeSeconds, Equals, 100)
1887
1888         // Set rule2
1889         err = client.SetBucketCORS(bucketNameTest, []CORSRule{rule2})
1890         c.Assert(err, IsNil)
1891
1892         time.Sleep(timeoutInOperation)
1893         gbcr, err = client.GetBucketCORS(bucketNameTest)
1894         c.Assert(err, IsNil)
1895         c.Assert(len(gbcr.CORSRules), Equals, 1)
1896         c.Assert(len(gbcr.CORSRules[0].AllowedOrigin), Equals, 2)
1897         c.Assert(len(gbcr.CORSRules[0].AllowedMethod), Equals, 1)
1898         c.Assert(len(gbcr.CORSRules[0].AllowedHeader), Equals, 1)
1899         c.Assert(len(gbcr.CORSRules[0].ExposeHeader), Equals, 2)
1900         c.Assert(gbcr.CORSRules[0].MaxAgeSeconds, Equals, 200)
1901
1902         // Reset
1903         err = client.SetBucketCORS(bucketNameTest, []CORSRule{rule1, rule2})
1904         c.Assert(err, IsNil)
1905
1906         time.Sleep(timeoutInOperation)
1907         gbcr, err = client.GetBucketCORS(bucketNameTest)
1908         c.Assert(err, IsNil)
1909         c.Assert(len(gbcr.CORSRules), Equals, 2)
1910
1911         // Set after delete
1912         err = client.DeleteBucketCORS(bucketNameTest)
1913         c.Assert(err, IsNil)
1914
1915         err = client.SetBucketCORS(bucketNameTest, []CORSRule{rule1, rule2})
1916         c.Assert(err, IsNil)
1917
1918         time.Sleep(timeoutInOperation)
1919         gbcr, err = client.GetBucketCORS(bucketNameTest)
1920         c.Assert(err, IsNil)
1921         c.Assert(len(gbcr.CORSRules), Equals, 2)
1922
1923         err = client.DeleteBucketCORS(bucketNameTest)
1924         c.Assert(err, IsNil)
1925
1926         err = client.DeleteBucket(bucketNameTest)
1927         c.Assert(err, IsNil)
1928 }
1929
1930 // TestDeleteBucketCORS
1931 func (s *OssClientSuite) TestDeleteBucketCORS(c *C) {
1932         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1933         var rule = CORSRule{
1934                 AllowedOrigin: []string{"*"},
1935                 AllowedMethod: []string{"PUT", "GET", "POST"},
1936                 AllowedHeader: []string{},
1937                 ExposeHeader:  []string{},
1938                 MaxAgeSeconds: 100,
1939         }
1940
1941         client, err := New(endpoint, accessID, accessKey)
1942         c.Assert(err, IsNil)
1943
1944         err = client.CreateBucket(bucketNameTest)
1945         c.Assert(err, IsNil)
1946         time.Sleep(timeoutInOperation)
1947
1948         // Delete not set
1949         err = client.DeleteBucketCORS(bucketNameTest)
1950         c.Assert(err, IsNil)
1951
1952         // Set
1953         err = client.SetBucketCORS(bucketNameTest, []CORSRule{rule})
1954         c.Assert(err, IsNil)
1955
1956         time.Sleep(timeoutInOperation)
1957         _, err = client.GetBucketCORS(bucketNameTest)
1958         c.Assert(err, IsNil)
1959
1960         // Detele
1961         err = client.DeleteBucketCORS(bucketNameTest)
1962         c.Assert(err, IsNil)
1963
1964         time.Sleep(timeoutInOperation)
1965         _, err = client.GetBucketCORS(bucketNameTest)
1966         c.Assert(err, NotNil)
1967
1968         // Detele after deleting
1969         err = client.DeleteBucketCORS(bucketNameTest)
1970         c.Assert(err, IsNil)
1971
1972         err = client.DeleteBucket(bucketNameTest)
1973         c.Assert(err, IsNil)
1974 }
1975
1976 // TestSetBucketCORSNegative
1977 func (s *OssClientSuite) TestSetBucketCORSNegative(c *C) {
1978         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
1979         var rule = CORSRule{
1980                 AllowedOrigin: []string{"*"},
1981                 AllowedMethod: []string{"PUT", "GET", "POST"},
1982                 AllowedHeader: []string{},
1983                 ExposeHeader:  []string{},
1984                 MaxAgeSeconds: 100,
1985         }
1986
1987         client, err := New(endpoint, accessID, accessKey)
1988         c.Assert(err, IsNil)
1989
1990         err = client.DeleteBucket(bucketNameTest)
1991
1992         // Not exist
1993         _, err = client.GetBucketCORS(bucketNameTest)
1994         c.Assert(err, NotNil)
1995
1996         err = client.DeleteBucketCORS(bucketNameTest)
1997         c.Assert(err, NotNil)
1998
1999         err = client.SetBucketCORS(bucketNameTest, []CORSRule{rule})
2000         c.Assert(err, NotNil)
2001
2002         err = client.CreateBucket(bucketNameTest)
2003         c.Assert(err, IsNil)
2004         time.Sleep(timeoutInOperation)
2005
2006         _, err = client.GetBucketCORS(bucketNameTest)
2007         c.Assert(err, NotNil)
2008
2009         // Set
2010         err = client.SetBucketCORS(bucketNameTest, []CORSRule{rule})
2011         c.Assert(err, IsNil)
2012         time.Sleep(timeoutInOperation)
2013
2014         _, err = client.GetBucketCORS(bucketNameTest)
2015         c.Assert(err, IsNil)
2016
2017         // Delete
2018         err = client.DeleteBucketCORS(bucketNameTest)
2019         c.Assert(err, IsNil)
2020
2021         time.Sleep(timeoutInOperation)
2022         _, err = client.GetBucketCORS(bucketNameTest)
2023         c.Assert(err, NotNil)
2024
2025         // Delete after deleting
2026         err = client.DeleteBucketCORS(bucketNameTest)
2027         c.Assert(err, IsNil)
2028
2029         err = client.DeleteBucket(bucketNameTest)
2030         c.Assert(err, IsNil)
2031 }
2032
2033 // TestGetBucketInfo
2034 func (s *OssClientSuite) TestGetBucketInfo(c *C) {
2035         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
2036
2037         client, err := New(endpoint, accessID, accessKey)
2038         c.Assert(err, IsNil)
2039
2040         err = client.CreateBucket(bucketNameTest)
2041         c.Assert(err, IsNil)
2042
2043         res, err := client.GetBucketInfo(bucketNameTest)
2044         c.Assert(err, IsNil)
2045         c.Assert(res.BucketInfo.Name, Equals, bucketNameTest)
2046         c.Assert(strings.HasPrefix(res.BucketInfo.Location, "oss-"), Equals, true)
2047         c.Assert(res.BucketInfo.ACL, Equals, "private")
2048         c.Assert(strings.HasSuffix(res.BucketInfo.ExtranetEndpoint, ".com"), Equals, true)
2049         c.Assert(strings.HasSuffix(res.BucketInfo.IntranetEndpoint, ".com"), Equals, true)
2050         c.Assert(res.BucketInfo.CreationDate, NotNil)
2051
2052         err = client.DeleteBucket(bucketNameTest)
2053         c.Assert(err, IsNil)
2054 }
2055
2056 // TestGetBucketInfoNegative
2057 func (s *OssClientSuite) TestGetBucketInfoNegative(c *C) {
2058         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
2059
2060         client, err := New(endpoint, accessID, accessKey)
2061         c.Assert(err, IsNil)
2062
2063         // Not exist
2064         _, err = client.GetBucketInfo(bucketNameTest)
2065         c.Assert(err, NotNil)
2066
2067         // Bucket name invalid
2068         _, err = client.GetBucketInfo("InvalidBucketName_")
2069         c.Assert(err, NotNil)
2070 }
2071
2072 // TestEndpointFormat
2073 func (s *OssClientSuite) TestEndpointFormat(c *C) {
2074         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
2075
2076         // http://host
2077         client, err := New(endpoint, accessID, accessKey)
2078         c.Assert(err, IsNil)
2079
2080         err = client.CreateBucket(bucketNameTest)
2081         c.Assert(err, IsNil)
2082         time.Sleep(timeoutInOperation)
2083
2084         res, err := client.GetBucketACL(bucketNameTest)
2085         c.Assert(err, IsNil)
2086         c.Assert(res.ACL, Equals, string(ACLPrivate))
2087
2088         err = client.DeleteBucket(bucketNameTest)
2089         c.Assert(err, IsNil)
2090         time.Sleep(timeoutInOperation)
2091
2092         // http://host:port
2093         client, err = New(endpoint+":80", accessID, accessKey)
2094         c.Assert(err, IsNil)
2095
2096         err = client.CreateBucket(bucketNameTest)
2097         c.Assert(err, IsNil)
2098
2099         time.Sleep(timeoutInOperation)
2100         res, err = client.GetBucketACL(bucketNameTest)
2101         c.Assert(err, IsNil)
2102         c.Assert(res.ACL, Equals, string(ACLPrivate))
2103
2104         err = client.DeleteBucket(bucketNameTest)
2105         c.Assert(err, IsNil)
2106 }
2107
2108 // TestCname
2109 func (s *OssClientSuite) _TestCname(c *C) {
2110         var bucketNameTest = "<my-bucket-cname>"
2111
2112         client, err := New("<endpoint>", "<accessKeyId>", "<accessKeySecret>", UseCname(true))
2113         c.Assert(err, IsNil)
2114
2115         err = client.CreateBucket(bucketNameTest)
2116         c.Assert(err, IsNil)
2117
2118         _, err = client.ListBuckets()
2119         c.Assert(err, NotNil)
2120
2121         res, err := client.GetBucketACL(bucketNameTest)
2122         c.Assert(err, IsNil)
2123         c.Assert(res.ACL, Equals, string(ACLPrivate))
2124 }
2125
2126 // TestCnameNegative
2127 func (s *OssClientSuite) _TestCnameNegative(c *C) {
2128         var bucketNameTest = "<my-bucket-cname>"
2129
2130         client, err := New("<endpoint>", "<accessKeyId>", "<accessKeySecret>", UseCname(true))
2131         c.Assert(err, IsNil)
2132
2133         err = client.CreateBucket(bucketNameTest)
2134         c.Assert(err, NotNil)
2135
2136         _, err = client.ListBuckets()
2137         c.Assert(err, NotNil)
2138
2139         _, err = client.GetBucketACL(bucketNameTest)
2140         c.Assert(err, NotNil)
2141 }
2142
2143 // _TestHTTPS
2144 func (s *OssClientSuite) _TestHTTPS(c *C) {
2145         var bucketNameTest = "<my-bucket-https>"
2146
2147         client, err := New("<endpoint>", "<accessKeyId>", "<accessKeySecret>")
2148         c.Assert(err, IsNil)
2149
2150         err = client.CreateBucket(bucketNameTest)
2151         c.Assert(err, IsNil)
2152
2153         res, err := client.GetBucketACL(bucketNameTest)
2154         c.Assert(err, IsNil)
2155         c.Assert(res.ACL, Equals, string(ACLPrivate))
2156
2157         err = client.DeleteBucket(bucketNameTest)
2158         c.Assert(err, IsNil)
2159 }
2160
2161 // TestClientOption
2162 func (s *OssClientSuite) TestClientOption(c *C) {
2163         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
2164
2165         client, err := New(endpoint, accessID, accessKey, UseCname(true),
2166                 Timeout(11, 12), SecurityToken("token"), Proxy(proxyHost))
2167         c.Assert(err, IsNil)
2168
2169         // CreateBucket timeout
2170         err = client.CreateBucket(bucketNameTest)
2171         c.Assert(err, NotNil)
2172
2173         c.Assert(client.Conn.config.HTTPTimeout.ConnectTimeout, Equals, time.Second*11)
2174         c.Assert(client.Conn.config.HTTPTimeout.ReadWriteTimeout, Equals, time.Second*12)
2175         c.Assert(client.Conn.config.HTTPTimeout.HeaderTimeout, Equals, time.Second*12)
2176         c.Assert(client.Conn.config.HTTPTimeout.IdleConnTimeout, Equals, time.Second*12)
2177         c.Assert(client.Conn.config.HTTPTimeout.LongTimeout, Equals, time.Second*12*10)
2178
2179         c.Assert(client.Conn.config.SecurityToken, Equals, "token")
2180         c.Assert(client.Conn.config.IsCname, Equals, true)
2181
2182         c.Assert(client.Conn.config.IsUseProxy, Equals, true)
2183         c.Assert(client.Config.ProxyHost, Equals, proxyHost)
2184
2185         client, err = New(endpoint, accessID, accessKey, AuthProxy(proxyHost, proxyUser, proxyPasswd))
2186
2187         c.Assert(client.Conn.config.IsUseProxy, Equals, true)
2188         c.Assert(client.Config.ProxyHost, Equals, proxyHost)
2189         c.Assert(client.Conn.config.IsAuthProxy, Equals, true)
2190         c.Assert(client.Conn.config.ProxyUser, Equals, proxyUser)
2191         c.Assert(client.Conn.config.ProxyPassword, Equals, proxyPasswd)
2192
2193         client, err = New(endpoint, accessID, accessKey, UserAgent("go sdk user agent"))
2194         c.Assert(client.Conn.config.UserAgent, Equals, "go sdk user agent")
2195
2196         // Check we can overide the http.Client
2197         httpClient := new(http.Client)
2198         client, err = New(endpoint, accessID, accessKey, HTTPClient(httpClient))
2199         c.Assert(client.HTTPClient, Equals, httpClient)
2200         c.Assert(client.Conn.client, Equals, httpClient)
2201         client, err = New(endpoint, accessID, accessKey)
2202         c.Assert(client.HTTPClient, IsNil)
2203 }
2204
2205 // TestProxy
2206 func (s *OssClientSuite) ProxyTestFunc(c *C, authVersion AuthVersionType, extraHeaders []string) {
2207         bucketNameTest := bucketNamePrefix + RandLowStr(6)
2208         objectName := "体育/奥运/首金"
2209         objectValue := "大江东去，浪淘尽，千古风流人物。 故垒西边，人道是、三国周郎赤壁。"
2210
2211         client, err := New(endpoint, accessID, accessKey, AuthProxy(proxyHost, proxyUser, proxyPasswd))
2212
2213         oldType := client.Config.AuthVersion
2214         oldHeaders := client.Config.AdditionalHeaders
2215         client.Config.AuthVersion = authVersion
2216         client.Config.AdditionalHeaders = extraHeaders
2217
2218         // Create bucket
2219         err = client.CreateBucket(bucketNameTest)
2220         c.Assert(err, IsNil)
2221
2222         // Get bucket info
2223         _, err = client.GetBucketInfo(bucketNameTest)
2224         c.Assert(err, IsNil)
2225
2226         bucket, err := client.Bucket(bucketNameTest)
2227
2228         // Sign URL
2229         str, err := bucket.SignURL(objectName, HTTPPut, 60)
2230         c.Assert(err, IsNil)
2231         if bucket.Client.Config.AuthVersion == AuthV1 {
2232                 c.Assert(strings.Contains(str, HTTPParamExpires+"="), Equals, true)
2233                 c.Assert(strings.Contains(str, HTTPParamAccessKeyID+"="), Equals, true)
2234                 c.Assert(strings.Contains(str, HTTPParamSignature+"="), Equals, true)
2235         } else {
2236                 c.Assert(strings.Contains(str, HTTPParamSignatureVersion+"=OSS2"), Equals, true)
2237                 c.Assert(strings.Contains(str, HTTPParamExpiresV2+"="), Equals, true)
2238                 c.Assert(strings.Contains(str, HTTPParamAccessKeyIDV2+"="), Equals, true)
2239                 c.Assert(strings.Contains(str, HTTPParamSignatureV2+"="), Equals, true)
2240         }
2241
2242         // Put object with URL
2243         err = bucket.PutObjectWithURL(str, strings.NewReader(objectValue))
2244         c.Assert(err, IsNil)
2245
2246         // Sign URL for get object
2247         str, err = bucket.SignURL(objectName, HTTPGet, 60)
2248         c.Assert(err, IsNil)
2249         if bucket.Client.Config.AuthVersion == AuthV1 {
2250                 c.Assert(strings.Contains(str, HTTPParamExpires+"="), Equals, true)
2251                 c.Assert(strings.Contains(str, HTTPParamAccessKeyID+"="), Equals, true)
2252                 c.Assert(strings.Contains(str, HTTPParamSignature+"="), Equals, true)
2253         } else {
2254                 c.Assert(strings.Contains(str, HTTPParamSignatureVersion+"=OSS2"), Equals, true)
2255                 c.Assert(strings.Contains(str, HTTPParamExpiresV2+"="), Equals, true)
2256                 c.Assert(strings.Contains(str, HTTPParamAccessKeyIDV2+"="), Equals, true)
2257                 c.Assert(strings.Contains(str, HTTPParamSignatureV2+"="), Equals, true)
2258         }
2259
2260         // Get object with URL
2261         body, err := bucket.GetObjectWithURL(str)
2262         c.Assert(err, IsNil)
2263         str, err = readBody(body)
2264         c.Assert(err, IsNil)
2265         c.Assert(str, Equals, objectValue)
2266
2267         // Put object
2268         err = bucket.PutObject(objectName, strings.NewReader(objectValue))
2269         c.Assert(err, IsNil)
2270
2271         // Get object
2272         _, err = bucket.GetObject(objectName)
2273         c.Assert(err, IsNil)
2274
2275         // List objects
2276         _, err = bucket.ListObjects()
2277         c.Assert(err, IsNil)
2278
2279         // Delete object
2280         err = bucket.DeleteObject(objectName)
2281         c.Assert(err, IsNil)
2282
2283         // Delete bucket
2284         err = client.DeleteBucket(bucketNameTest)
2285         c.Assert(err, IsNil)
2286
2287         client.Config.AuthVersion = oldType
2288         client.Config.AdditionalHeaders = oldHeaders
2289 }
2290
2291 func (s *OssClientSuite) TestProxy(c *C) {
2292         s.ProxyTestFunc(c, AuthV1, []string{})
2293         s.ProxyTestFunc(c, AuthV2, []string{})
2294         s.ProxyTestFunc(c, AuthV2, []string{"host", "range", "user-agent"})
2295 }
2296
2297 // TestProxy for https endpoint
2298 func (s *OssClientSuite) TestHttpsEndpointProxy(c *C) {
2299         bucketNameTest := bucketNamePrefix + RandLowStr(6)
2300         objectName := objectNamePrefix + RandLowStr(6)
2301         objectValue := RandLowStr(100)
2302
2303         httpsEndPoint := ""
2304         if strings.HasPrefix(endpoint, "http://") {
2305                 httpsEndPoint = strings.Replace(endpoint, "http://", "https://", 1)
2306         } else if !strings.HasPrefix(endpoint, "https://") {
2307                 httpsEndPoint = "https://" + endpoint
2308         } else {
2309                 httpsEndPoint = endpoint
2310         }
2311
2312         client, err := New(httpsEndPoint, accessID, accessKey, AuthProxy(proxyHost, proxyUser, proxyPasswd))
2313
2314         // Create bucket
2315         err = client.CreateBucket(bucketNameTest)
2316         c.Assert(err, IsNil)
2317
2318         bucket, err := client.Bucket(bucketNameTest)
2319
2320         // Put object
2321         err = bucket.PutObject(objectName, strings.NewReader(objectValue))
2322         c.Assert(err, IsNil)
2323
2324         // Get object
2325         _, err = bucket.GetObject(objectName)
2326         c.Assert(err, IsNil)
2327
2328         // List objects
2329         _, err = bucket.ListObjects()
2330         c.Assert(err, IsNil)
2331
2332         // Delete object
2333         err = bucket.DeleteObject(objectName)
2334         c.Assert(err, IsNil)
2335
2336         // Delete bucket
2337         err = client.DeleteBucket(bucketNameTest)
2338         c.Assert(err, IsNil)
2339 }
2340
2341 // Private
2342 func (s *OssClientSuite) checkBucket(buckets []BucketProperties, bucket string) bool {
2343         for _, v := range buckets {
2344                 if v.Name == bucket {
2345                         return true
2346                 }
2347         }
2348         return false
2349 }
2350
2351 func (s *OssClientSuite) getBucket(buckets []BucketProperties, bucket string) (bool, BucketProperties) {
2352         for _, v := range buckets {
2353                 if v.Name == bucket {
2354                         return true, v
2355                 }
2356         }
2357         return false, BucketProperties{}
2358 }
2359
2360 func (s *OssClientSuite) TestHttpLogNotSignUrl(c *C) {
2361         logName := "." + string(os.PathSeparator) + "test-go-sdk-httpdebug.log" + RandStr(5)
2362         f, err := os.OpenFile(logName, os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0660)
2363         c.Assert(err, IsNil)
2364
2365         client, err := New(endpoint, accessID, accessKey)
2366         client.Config.LogLevel = Debug
2367
2368         client.Config.Logger = log.New(f, "", log.LstdFlags)
2369
2370         var testBucketName = bucketNamePrefix + RandLowStr(6)
2371
2372         // CreateBucket
2373         err = client.CreateBucket(testBucketName)
2374         f.Close()
2375
2376         // read log file,get http info
2377         contents, err := ioutil.ReadFile(logName)
2378         c.Assert(err, IsNil)
2379
2380         httpContent := string(contents)
2381         //fmt.Println(httpContent)
2382
2383         c.Assert(strings.Contains(httpContent, "signStr"), Equals, true)
2384         c.Assert(strings.Contains(httpContent, "Method:"), Equals, true)
2385
2386         // delete test bucket and log
2387         os.Remove(logName)
2388         client.DeleteBucket(testBucketName)
2389 }
2390
2391 func (s *OssClientSuite) HttpLogSignUrlTestFunc(c *C, authVersion AuthVersionType, extraHeaders []string) {
2392         logName := "." + string(os.PathSeparator) + "test-go-sdk-httpdebug-signurl.log" + RandStr(5)
2393         f, err := os.OpenFile(logName, os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0660)
2394         c.Assert(err, IsNil)
2395
2396         client, err := New(endpoint, accessID, accessKey)
2397         client.Config.LogLevel = Debug
2398         client.Config.Logger = log.New(f, "", log.LstdFlags)
2399
2400         oldType := client.Config.AuthVersion
2401         oldHeaders := client.Config.AdditionalHeaders
2402         client.Config.AuthVersion = authVersion
2403         client.Config.AdditionalHeaders = extraHeaders
2404
2405         var testBucketName = bucketNamePrefix + RandLowStr(6)
2406
2407         // CreateBucket
2408         err = client.CreateBucket(testBucketName)
2409         f.Close()
2410
2411         // clear log
2412         f, err = os.OpenFile(logName, os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0660)
2413         client.Config.Logger = log.New(f, "", log.LstdFlags)
2414
2415         bucket, _ := client.Bucket(testBucketName)
2416         objectName := objectNamePrefix + RandStr(8)
2417         objectValue := RandStr(20)
2418
2419         // Sign URL for put
2420         str, err := bucket.SignURL(objectName, HTTPPut, 60)
2421         c.Assert(err, IsNil)
2422         if bucket.Client.Config.AuthVersion == AuthV1 {
2423                 c.Assert(strings.Contains(str, HTTPParamExpires+"="), Equals, true)
2424                 c.Assert(strings.Contains(str, HTTPParamAccessKeyID+"="), Equals, true)
2425                 c.Assert(strings.Contains(str, HTTPParamSignature+"="), Equals, true)
2426         } else {
2427                 c.Assert(strings.Contains(str, HTTPParamSignatureVersion+"=OSS2"), Equals, true)
2428                 c.Assert(strings.Contains(str, HTTPParamExpiresV2+"="), Equals, true)
2429                 c.Assert(strings.Contains(str, HTTPParamAccessKeyIDV2+"="), Equals, true)
2430                 c.Assert(strings.Contains(str, HTTPParamSignatureV2+"="), Equals, true)
2431         }
2432
2433         // Error put object with URL
2434         err = bucket.PutObjectWithURL(str, strings.NewReader(objectValue), ContentType("image/tiff"))
2435         f.Close()
2436
2437         // read log file,get http info
2438         contents, err := ioutil.ReadFile(logName)
2439         c.Assert(err, IsNil)
2440
2441         httpContent := string(contents)
2442         //fmt.Println(httpContent)
2443
2444         c.Assert(strings.Contains(httpContent, "signStr"), Equals, true)
2445         c.Assert(strings.Contains(httpContent, "Method:"), Equals, true)
2446
2447         // delete test bucket and log
2448         os.Remove(logName)
2449         client.DeleteBucket(testBucketName)
2450
2451         client.Config.AuthVersion = oldType
2452         client.Config.AdditionalHeaders = oldHeaders
2453 }
2454
2455 func (s *OssClientSuite) TestHttpLogSignUrl(c *C) {
2456         s.HttpLogSignUrlTestFunc(c, AuthV1, []string{})
2457         s.HttpLogSignUrlTestFunc(c, AuthV2, []string{})
2458         s.HttpLogSignUrlTestFunc(c, AuthV2, []string{"host", "range", "user-agent"})
2459 }
2460
2461 func (s *OssClientSuite) TestSetLimitUploadSpeed(c *C) {
2462         client, err := New(endpoint, accessID, accessKey)
2463         c.Assert(err, IsNil)
2464
2465         err = client.LimitUploadSpeed(100)
2466
2467         goVersion := runtime.Version()
2468         pSlice := strings.Split(strings.ToLower(goVersion), ".")
2469
2470         // compare with go1.7
2471         if len(pSlice) >= 2 {
2472                 if pSlice[0] > "go1" {
2473                         c.Assert(err, IsNil)
2474                 } else if pSlice[0] == "go1" {
2475                         subVersion, _ := strconv.Atoi(pSlice[1])
2476                         if subVersion >= 7 {
2477                                 c.Assert(err, IsNil)
2478                         } else {
2479                                 c.Assert(err, NotNil)
2480                         }
2481                 } else {
2482                         c.Assert(err, NotNil)
2483                 }
2484         }
2485 }
2486
2487 func (s *OssClientSuite) TestBucketEncyptionError(c *C) {
2488         client, err := New(endpoint, accessID, accessKey)
2489         c.Assert(err, IsNil)
2490
2491         bucketName := bucketNamePrefix + RandLowStr(5)
2492         err = client.CreateBucket(bucketName)
2493         c.Assert(err, IsNil)
2494
2495         // SetBucketEncryption:AES256 ,"123"
2496         encryptionRule := ServerEncryptionRule{}
2497         encryptionRule.SSEDefault.SSEAlgorithm = string(AESAlgorithm)
2498         encryptionRule.SSEDefault.KMSMasterKeyID = "123"
2499
2500         var responseHeader http.Header
2501         err = client.SetBucketEncryption(bucketName, encryptionRule, GetResponseHeader(&responseHeader))
2502         c.Assert(err, NotNil)
2503         requestId := GetRequestId(responseHeader)
2504         c.Assert(len(requestId) > 0, Equals, true)
2505
2506         // GetBucketEncryption
2507         _, err = client.GetBucketEncryption(bucketName, GetResponseHeader(&responseHeader))
2508         c.Assert(err, NotNil)
2509         requestId = GetRequestId(responseHeader)
2510         c.Assert(len(requestId) > 0, Equals, true)
2511
2512         // Get default bucket info
2513         bucketResult, err := client.GetBucketInfo(bucketName)
2514         c.Assert(err, IsNil)
2515
2516         c.Assert(bucketResult.BucketInfo.SseRule.SSEAlgorithm, Equals, "")
2517         c.Assert(bucketResult.BucketInfo.SseRule.KMSMasterKeyID, Equals, "")
2518         c.Assert(bucketResult.BucketInfo.Versioning, Equals, "")
2519
2520         err = client.DeleteBucket(bucketName)
2521         c.Assert(err, IsNil)
2522 }
2523
2524 func (s *OssClientSuite) TestBucketEncryptionPutAndGetAndDelete(c *C) {
2525         client, err := New(endpoint, accessID, accessKey)
2526         c.Assert(err, IsNil)
2527
2528         bucketName := bucketNamePrefix + RandLowStr(5)
2529         err = client.CreateBucket(bucketName)
2530         c.Assert(err, IsNil)
2531
2532         // SetBucketEncryption:KMS ,""
2533         encryptionRule := ServerEncryptionRule{}
2534         encryptionRule.SSEDefault.SSEAlgorithm = string(KMSAlgorithm)
2535
2536         var responseHeader http.Header
2537         err = client.SetBucketEncryption(bucketName, encryptionRule, GetResponseHeader(&responseHeader))
2538         c.Assert(err, IsNil)
2539         requestId := GetRequestId(responseHeader)
2540         c.Assert(len(requestId) > 0, Equals, true)
2541
2542         // GetBucketEncryption
2543         getResult, err := client.GetBucketEncryption(bucketName, GetResponseHeader(&responseHeader))
2544         c.Assert(err, IsNil)
2545         requestId = GetRequestId(responseHeader)
2546         c.Assert(len(requestId) > 0, Equals, true)
2547
2548         // check encryption value
2549         c.Assert(encryptionRule.SSEDefault.SSEAlgorithm, Equals, getResult.SSEDefault.SSEAlgorithm)
2550         c.Assert(encryptionRule.SSEDefault.KMSMasterKeyID, Equals, getResult.SSEDefault.KMSMasterKeyID)
2551
2552         // delete bucket encyption
2553         err = client.DeleteBucketEncryption(bucketName, GetResponseHeader(&responseHeader))
2554         c.Assert(err, IsNil)
2555         requestId = GetRequestId(responseHeader)
2556         c.Assert(len(requestId) > 0, Equals, true)
2557
2558         // GetBucketEncryption failure
2559         _, err = client.GetBucketEncryption(bucketName, GetResponseHeader(&responseHeader))
2560         c.Assert(err, NotNil)
2561         requestId = GetRequestId(responseHeader)
2562         c.Assert(len(requestId) > 0, Equals, true)
2563
2564         // Get default bucket info
2565         bucketResult, err := client.GetBucketInfo(bucketName)
2566         c.Assert(err, IsNil)
2567
2568         c.Assert(bucketResult.BucketInfo.SseRule.SSEAlgorithm, Equals, "")
2569         c.Assert(bucketResult.BucketInfo.SseRule.KMSMasterKeyID, Equals, "")
2570         c.Assert(bucketResult.BucketInfo.Versioning, Equals, "")
2571
2572         err = client.DeleteBucket(bucketName)
2573         c.Assert(err, IsNil)
2574 }
2575
2576 func (s *OssClientSuite) TestBucketEncryptionWithSm4(c *C) {
2577         client, err := New(endpoint, accessID, accessKey)
2578         c.Assert(err, IsNil)
2579
2580         bucketName := bucketNamePrefix + RandLowStr(5)
2581         err = client.CreateBucket(bucketName)
2582         c.Assert(err, IsNil)
2583
2584         // SetBucketEncryption:SM4 ,""
2585         encryptionRule := ServerEncryptionRule{}
2586         encryptionRule.SSEDefault.SSEAlgorithm = string(SM4Algorithm)
2587
2588         var responseHeader http.Header
2589         err = client.SetBucketEncryption(bucketName, encryptionRule, GetResponseHeader(&responseHeader))
2590         c.Assert(err, IsNil)
2591         requestId := GetRequestId(responseHeader)
2592         c.Assert(len(requestId) > 0, Equals, true)
2593
2594         // GetBucketEncryption
2595         getResult, err := client.GetBucketEncryption(bucketName, GetResponseHeader(&responseHeader))
2596         c.Assert(err, IsNil)
2597         requestId = GetRequestId(responseHeader)
2598         c.Assert(len(requestId) > 0, Equals, true)
2599
2600         // check encryption value
2601         c.Assert(getResult.SSEDefault.SSEAlgorithm, Equals, string(SM4Algorithm))
2602         c.Assert(getResult.SSEDefault.KMSMasterKeyID, Equals, "")
2603         c.Assert(getResult.SSEDefault.KMSDataEncryption, Equals, "")
2604
2605         // Get default bucket info
2606         bucketResult, err := client.GetBucketInfo(bucketName)
2607         c.Assert(err, IsNil)
2608
2609         c.Assert(bucketResult.BucketInfo.SseRule.SSEAlgorithm, Equals, string(SM4Algorithm))
2610         c.Assert(bucketResult.BucketInfo.SseRule.KMSMasterKeyID, Equals, "")
2611         c.Assert(bucketResult.BucketInfo.SseRule.KMSDataEncryption, Equals, "")
2612
2613         err = client.DeleteBucket(bucketName)
2614         c.Assert(err, IsNil)
2615 }
2616
2617 func (s *OssClientSuite) TestBucketEncryptionWithKmsSm4(c *C) {
2618         client, err := New(endpoint, accessID, accessKey)
2619         c.Assert(err, IsNil)
2620
2621         bucketName := bucketNamePrefix + RandLowStr(5)
2622         err = client.CreateBucket(bucketName)
2623         c.Assert(err, IsNil)
2624
2625         // SetBucketEncryption:SM4 ,""
2626         encryptionRule := ServerEncryptionRule{}
2627         encryptionRule.SSEDefault.SSEAlgorithm = string(KMSAlgorithm)
2628         encryptionRule.SSEDefault.KMSDataEncryption = string(SM4Algorithm)
2629
2630         var responseHeader http.Header
2631         err = client.SetBucketEncryption(bucketName, encryptionRule, GetResponseHeader(&responseHeader))
2632         c.Assert(err, IsNil)
2633         requestId := GetRequestId(responseHeader)
2634         c.Assert(len(requestId) > 0, Equals, true)
2635
2636         // GetBucketEncryption
2637         getResult, err := client.GetBucketEncryption(bucketName, GetResponseHeader(&responseHeader))
2638         c.Assert(err, IsNil)
2639         requestId = GetRequestId(responseHeader)
2640         c.Assert(len(requestId) > 0, Equals, true)
2641
2642         // check encryption value
2643         c.Assert(getResult.SSEDefault.SSEAlgorithm, Equals, string(KMSAlgorithm))
2644         c.Assert(getResult.SSEDefault.KMSMasterKeyID, Equals, "")
2645         c.Assert(getResult.SSEDefault.KMSDataEncryption, Equals, string(SM4Algorithm))
2646
2647         // Get default bucket info
2648         bucketResult, err := client.GetBucketInfo(bucketName)
2649         c.Assert(err, IsNil)
2650
2651         c.Assert(bucketResult.BucketInfo.SseRule.SSEAlgorithm, Equals, string(KMSAlgorithm))
2652         c.Assert(bucketResult.BucketInfo.SseRule.KMSMasterKeyID, Equals, "")
2653         c.Assert(bucketResult.BucketInfo.SseRule.KMSDataEncryption, Equals, string(SM4Algorithm))
2654
2655         err = client.DeleteBucket(bucketName)
2656         c.Assert(err, IsNil)
2657 }
2658
2659 func (s *OssClientSuite) TestBucketEncyptionPutObjectSuccess(c *C) {
2660         client, err := New(endpoint, accessID, accessKey)
2661         c.Assert(err, IsNil)
2662
2663         bucketName := bucketNamePrefix + RandLowStr(5)
2664         err = client.CreateBucket(bucketName)
2665         c.Assert(err, IsNil)
2666
2667         // SetBucketEncryption:KMS ,""
2668         encryptionRule := ServerEncryptionRule{}
2669         encryptionRule.SSEDefault.SSEAlgorithm = string(KMSAlgorithm)
2670
2671         var responseHeader http.Header
2672         err = client.SetBucketEncryption(bucketName, encryptionRule, GetResponseHeader(&responseHeader))
2673         c.Assert(err, IsNil)
2674         requestId := GetRequestId(responseHeader)
2675         c.Assert(len(requestId) > 0, Equals, true)
2676
2677         // GetBucketEncryption
2678         getResult, err := client.GetBucketEncryption(bucketName, GetResponseHeader(&responseHeader))
2679         c.Assert(err, IsNil)
2680         requestId = GetRequestId(responseHeader)
2681         c.Assert(len(requestId) > 0, Equals, true)
2682
2683         // check encryption value
2684         c.Assert(encryptionRule.SSEDefault.SSEAlgorithm, Equals, getResult.SSEDefault.SSEAlgorithm)
2685         c.Assert(encryptionRule.SSEDefault.KMSMasterKeyID, Equals, getResult.SSEDefault.KMSMasterKeyID)
2686
2687         // Get default bucket info
2688         bucketResult, err := client.GetBucketInfo(bucketName)
2689         c.Assert(err, IsNil)
2690
2691         c.Assert(bucketResult.BucketInfo.SseRule.SSEAlgorithm, Equals, "KMS")
2692         c.Assert(bucketResult.BucketInfo.SseRule.KMSMasterKeyID, Equals, "")
2693         c.Assert(bucketResult.BucketInfo.Versioning, Equals, "")
2694
2695         err = client.DeleteBucket(bucketName)
2696         c.Assert(err, IsNil)
2697 }
2698
2699 func (s *OssClientSuite) TestBucketEncyptionPutObjectError(c *C) {
2700         client, err := New(endpoint, accessID, accessKey)
2701         c.Assert(err, IsNil)
2702
2703         bucketName := bucketNamePrefix + RandLowStr(5)
2704         err = client.CreateBucket(bucketName)
2705         c.Assert(err, IsNil)
2706
2707         // SetBucketEncryption:KMS ,""
2708         encryptionRule := ServerEncryptionRule{}
2709         encryptionRule.SSEDefault.SSEAlgorithm = string(KMSAlgorithm)
2710         kmsId := "123"
2711         encryptionRule.SSEDefault.KMSMasterKeyID = kmsId
2712
2713         var responseHeader http.Header
2714         err = client.SetBucketEncryption(bucketName, encryptionRule, GetResponseHeader(&responseHeader))
2715         c.Assert(err, IsNil)
2716         requestId := GetRequestId(responseHeader)
2717         c.Assert(len(requestId) > 0, Equals, true)
2718
2719         // GetBucketEncryption
2720         getResult, err := client.GetBucketEncryption(bucketName, GetResponseHeader(&responseHeader))
2721         c.Assert(err, IsNil)
2722         requestId = GetRequestId(responseHeader)
2723         c.Assert(len(requestId) > 0, Equals, true)
2724
2725         // check encryption value
2726         c.Assert(encryptionRule.SSEDefault.SSEAlgorithm, Equals, getResult.SSEDefault.SSEAlgorithm)
2727         c.Assert(encryptionRule.SSEDefault.KMSMasterKeyID, Equals, getResult.SSEDefault.KMSMasterKeyID)
2728
2729         // Get default bucket info
2730         bucketResult, err := client.GetBucketInfo(bucketName)
2731         c.Assert(err, IsNil)
2732
2733         c.Assert(bucketResult.BucketInfo.SseRule.SSEAlgorithm, Equals, "KMS")
2734         c.Assert(bucketResult.BucketInfo.SseRule.KMSMasterKeyID, Equals, kmsId)
2735         c.Assert(bucketResult.BucketInfo.Versioning, Equals, "")
2736
2737         // put and get object failure
2738         bucket, err := client.Bucket(bucketName)
2739         c.Assert(err, IsNil)
2740
2741         // put object failure
2742         objectName := objectNamePrefix + RandStr(8)
2743         context := RandStr(100)
2744         err = bucket.PutObject(objectName, strings.NewReader(context))
2745         c.Assert(err, NotNil)
2746
2747         err = client.DeleteBucket(bucketName)
2748         c.Assert(err, IsNil)
2749 }
2750
2751 func (s *OssClientSuite) TestBucketTaggingOperation(c *C) {
2752         client, err := New(endpoint, accessID, accessKey)
2753         c.Assert(err, IsNil)
2754
2755         bucketName := bucketNamePrefix + RandLowStr(5)
2756         err = client.CreateBucket(bucketName)
2757         c.Assert(err, IsNil)
2758
2759         var respHeader http.Header
2760
2761         // Bucket Tagging
2762         var tagging Tagging
2763         tagging.Tags = []Tag{Tag{Key: "testkey2", Value: "testvalue2"}}
2764         err = client.SetBucketTagging(bucketName, tagging, GetResponseHeader(&respHeader))
2765         c.Assert(err, IsNil)
2766         c.Assert(GetRequestId(respHeader) != "", Equals, true)
2767
2768         getResult, err := client.GetBucketTagging(bucketName)
2769         c.Assert(err, IsNil)
2770         c.Assert(getResult.Tags[0].Key, Equals, tagging.Tags[0].Key)
2771         c.Assert(getResult.Tags[0].Value, Equals, tagging.Tags[0].Value)
2772
2773         // delete BucketTagging
2774         err = client.DeleteBucketTagging(bucketName, GetResponseHeader(&respHeader))
2775         c.Assert(err, IsNil)
2776         c.Assert(GetRequestId(respHeader) != "", Equals, true)
2777
2778         getResult, err = client.GetBucketTagging(bucketName, GetResponseHeader(&respHeader))
2779         c.Assert(err, IsNil)
2780         c.Assert(GetRequestId(respHeader) != "", Equals, true)
2781         c.Assert(len(getResult.Tags), Equals, 0)
2782
2783         err = client.DeleteBucket(bucketName)
2784         c.Assert(err, IsNil)
2785 }
2786
2787 func (s *OssClientSuite) TestListBucketsTagging(c *C) {
2788         client, err := New(endpoint, accessID, accessKey)
2789         c.Assert(err, IsNil)
2790
2791         bucketName1 := bucketNamePrefix + RandLowStr(5)
2792         err = client.CreateBucket(bucketName1)
2793         c.Assert(err, IsNil)
2794
2795         bucketName2 := bucketNamePrefix + RandLowStr(5)
2796         err = client.CreateBucket(bucketName2)
2797         c.Assert(err, IsNil)
2798
2799         // Bucket Tagging
2800         var tagging Tagging
2801         tagging.Tags = []Tag{Tag{Key: "testkey", Value: "testvalue"}}
2802         err = client.SetBucketTagging(bucketName1, tagging)
2803         c.Assert(err, IsNil)
2804
2805         // list bucket
2806         listResult, err := client.ListBuckets(TagKey("testkey"))
2807         c.Assert(err, IsNil)
2808         c.Assert(len(listResult.Buckets), Equals, 1)
2809         c.Assert(listResult.Buckets[0].Name, Equals, bucketName1)
2810
2811         client.DeleteBucket(bucketName1)
2812         client.DeleteBucket(bucketName2)
2813 }
2814
2815 func (s *OssClientSuite) TestGetBucketStat(c *C) {
2816         client, err := New(endpoint, accessID, accessKey)
2817         c.Assert(err, IsNil)
2818
2819         bucketName := bucketNamePrefix + RandLowStr(5)
2820         err = client.CreateBucket(bucketName)
2821         c.Assert(err, IsNil)
2822
2823         bucket, err := client.Bucket(bucketName)
2824         c.Assert(err, IsNil)
2825
2826         // put object
2827         objectName := objectNamePrefix + RandLowStr(5)
2828         err = bucket.PutObject(objectName, strings.NewReader(RandStr(10)))
2829         c.Assert(err, IsNil)
2830
2831         bucket.DeleteObject(objectName)
2832         err = bucket.PutObject(objectName, strings.NewReader(RandStr(10)))
2833         c.Assert(err, IsNil)
2834         bucket.DeleteObject(objectName)
2835
2836         _, err = client.GetBucketStat(bucketName)
2837         c.Assert(err, IsNil)
2838
2839         client.DeleteBucket(bucketName)
2840 }
2841
2842 func (s *OssBucketSuite) TestGetBucketVersioning(c *C) {
2843         // create a bucket with default proprety
2844         client, err := New(endpoint, accessID, accessKey)
2845         c.Assert(err, IsNil)
2846
2847         bucketName := bucketNamePrefix + RandLowStr(6)
2848
2849         var respHeader http.Header
2850         err = client.CreateBucket(bucketName, GetResponseHeader(&respHeader))
2851         c.Assert(err, IsNil)
2852         c.Assert(GetRequestId(respHeader) != "", Equals, true)
2853
2854         // put bucket version:enabled
2855         var versioningConfig VersioningConfig
2856         versioningConfig.Status = string(VersionEnabled)
2857         err = client.SetBucketVersioning(bucketName, versioningConfig)
2858         c.Assert(err, IsNil)
2859
2860         // get bucket version success
2861         versioningResult, err := client.GetBucketVersioning(bucketName, GetResponseHeader(&respHeader))
2862         c.Assert(versioningResult.Status, Equals, "Enabled")
2863         c.Assert(GetRequestId(respHeader) != "", Equals, true)
2864
2865         ForceDeleteBucket(client, bucketName, c)
2866 }
2867
2868 func (s *OssClientSuite) TestBucketPolicy(c *C) {
2869         client, err := New(endpoint, accessID, accessKey)
2870         c.Assert(err, IsNil)
2871
2872         bucketName := bucketNamePrefix + RandLowStr(5)
2873         err = client.CreateBucket(bucketName)
2874         c.Assert(err, IsNil)
2875
2876         var responseHeader http.Header
2877         ret, err := client.GetBucketPolicy(bucketName, GetResponseHeader(&responseHeader))
2878         c.Assert(err, NotNil)
2879         requestId := GetRequestId(responseHeader)
2880         c.Assert(len(requestId) > 0, Equals, true)
2881
2882         policyInfo := `
2883         {
2884                 "Version":"1",
2885                 "Statement":[
2886                         {
2887                                 "Action":[
2888                                         "oss:GetObject",
2889                                         "oss:PutObject"
2890                                 ],
2891                                 "Effect":"Deny",
2892                                 "Principal":"[123456790]",
2893                                 "Resource":["acs:oss:*:1234567890:*/*"]
2894                         }
2895                 ]
2896         }`
2897
2898         err = client.SetBucketPolicy(bucketName, policyInfo, GetResponseHeader(&responseHeader))
2899         c.Assert(err, IsNil)
2900         requestId = GetRequestId(responseHeader)
2901         c.Assert(len(requestId) > 0, Equals, true)
2902
2903         ret, err = client.GetBucketPolicy(bucketName, GetResponseHeader(&responseHeader))
2904         c.Assert(err, IsNil)
2905         testLogger.Println("policy:", ret)
2906         c.Assert(ret, Equals, policyInfo)
2907         requestId = GetRequestId(responseHeader)
2908         c.Assert(len(requestId) > 0, Equals, true)
2909
2910         err = client.DeleteBucketPolicy(bucketName, GetResponseHeader(&responseHeader))
2911         c.Assert(err, IsNil)
2912         requestId = GetRequestId(responseHeader)
2913         c.Assert(len(requestId) > 0, Equals, true)
2914         client.DeleteBucket(bucketName)
2915 }
2916
2917 func (s *OssClientSuite) TestBucketPolicyNegative(c *C) {
2918         client, err := New(endpoint, accessID, accessKey)
2919         c.Assert(err, IsNil)
2920
2921         bucketName := bucketNamePrefix + RandLowStr(5)
2922         err = client.CreateBucket(bucketName)
2923         c.Assert(err, IsNil)
2924
2925         var responseHeader http.Header
2926         _, err = client.GetBucketPolicy(bucketName, GetResponseHeader(&responseHeader))
2927         c.Assert(err, NotNil)
2928         requestId := GetRequestId(responseHeader)
2929         c.Assert(len(requestId) > 0, Equals, true)
2930
2931         // Setting the Version is 2, this is error policy
2932         errPolicy := `
2933         {
2934                 "Version":"2",
2935                 "Statement":[
2936                         {
2937                                 "Action":[
2938                                         "oss:GetObject",
2939                                         "oss:PutObject"
2940                                 ],
2941                                 "Effect":"Deny",
2942                                 "Principal":"[123456790]",
2943                                 "Resource":["acs:oss:*:1234567890:*/*"]
2944                         }
2945                 ]
2946         }`
2947         err = client.SetBucketPolicy(bucketName, errPolicy, GetResponseHeader(&responseHeader))
2948         c.Assert(err, NotNil)
2949         testLogger.Println("err:", err)
2950         requestId = GetRequestId(responseHeader)
2951         c.Assert(len(requestId) > 0, Equals, true)
2952
2953         err = client.DeleteBucketPolicy(bucketName, GetResponseHeader(&responseHeader))
2954         c.Assert(err, IsNil)
2955
2956         bucketNameEmpty := bucketNamePrefix + RandLowStr(5)
2957         client.DeleteBucket(bucketNameEmpty)
2958
2959         err = client.DeleteBucketPolicy(bucketNameEmpty, GetResponseHeader(&responseHeader))
2960         c.Assert(err, NotNil)
2961         requestId = GetRequestId(responseHeader)
2962         c.Assert(len(requestId) > 0, Equals, true)
2963
2964         client.DeleteBucket(bucketName)
2965 }
2966
2967 func (s *OssClientSuite) TestSetBucketRequestPayment(c *C) {
2968         client, err := New(endpoint, accessID, accessKey)
2969         c.Assert(err, IsNil)
2970
2971         bucketName := bucketNamePrefix + RandLowStr(5)
2972         err = client.CreateBucket(bucketName)
2973         c.Assert(err, IsNil)
2974
2975         reqPayConf := RequestPaymentConfiguration{
2976                 Payer: "Requester",
2977         }
2978         err = client.SetBucketRequestPayment(bucketName, reqPayConf)
2979         c.Assert(err, IsNil)
2980
2981         ret, err := client.GetBucketRequestPayment(bucketName)
2982         c.Assert(err, IsNil)
2983         c.Assert(ret.Payer, Equals, "Requester")
2984
2985         client.DeleteBucket(bucketName)
2986         c.Assert(err, IsNil)
2987 }
2988
2989 func (s *OssClientSuite) TestSetBucketRequestPaymentNegative(c *C) {
2990         client, err := New(endpoint, accessID, accessKey)
2991         c.Assert(err, IsNil)
2992
2993         bucketName := bucketNamePrefix + RandLowStr(5)
2994         err = client.CreateBucket(bucketName)
2995         c.Assert(err, IsNil)
2996
2997         reqPayConf := RequestPaymentConfiguration{
2998                 Payer: "Requesterttttt", // this is a error configuration
2999         }
3000         err = client.SetBucketRequestPayment(bucketName, reqPayConf)
3001         c.Assert(err, NotNil)
3002
3003         ret, err := client.GetBucketRequestPayment(bucketName)
3004         c.Assert(err, IsNil)
3005         c.Assert(ret.Payer, Equals, "BucketOwner")
3006
3007         client.DeleteBucket(bucketName)
3008         c.Assert(err, IsNil)
3009 }
3010
3011 func (s *OssClientSuite) TestBucketQos(c *C) {
3012         client, err := New(endpoint, accessID, accessKey)
3013         c.Assert(err, IsNil)
3014
3015         ret, err := client.GetUserQoSInfo()
3016         c.Assert(err, IsNil)
3017         testLogger.Println("QosInfo:", ret)
3018
3019         bucketName := bucketNamePrefix + RandLowStr(5)
3020         _ = client.DeleteBucket(bucketName)
3021
3022         err = client.CreateBucket(bucketName)
3023         c.Assert(err, IsNil)
3024
3025         _, err = client.GetBucketQosInfo(bucketName)
3026         c.Assert(err, NotNil)
3027
3028         // case 1 set BucketQoSConfiguration every member
3029         five := 5
3030         four := 4
3031         totalQps := 200
3032         qosConf := BucketQoSConfiguration{
3033                 TotalUploadBandwidth:      &five,
3034                 IntranetUploadBandwidth:   &four,
3035                 ExtranetUploadBandwidth:   &four,
3036                 TotalDownloadBandwidth:    &four,
3037                 IntranetDownloadBandwidth: &four,
3038                 ExtranetDownloadBandwidth: &four,
3039                 TotalQPS:                  &totalQps,
3040                 IntranetQPS:               &totalQps,
3041                 ExtranetQPS:               &totalQps,
3042         }
3043         var responseHeader http.Header
3044         err = client.SetBucketQoSInfo(bucketName, qosConf, GetResponseHeader(&responseHeader))
3045         c.Assert(err, IsNil)
3046         requestId := GetRequestId(responseHeader)
3047         c.Assert(len(requestId) > 0, Equals, true)
3048
3049         // wait a moment for configuration effect
3050         time.Sleep(time.Second)
3051
3052         retQos, err := client.GetBucketQosInfo(bucketName)
3053         c.Assert(err, IsNil)
3054
3055         // set qosConf default value
3056         qosConf.XMLName.Local = "QoSConfiguration"
3057         c.Assert(struct2string(retQos, c), Equals, struct2string(qosConf, c))
3058
3059         // case 2 set BucketQoSConfiguration not every member
3060         qosConfNo := BucketQoSConfiguration{
3061                 TotalUploadBandwidth:      &five,
3062                 IntranetUploadBandwidth:   &four,
3063                 ExtranetUploadBandwidth:   &four,
3064                 TotalDownloadBandwidth:    &four,
3065                 IntranetDownloadBandwidth: &four,
3066                 ExtranetDownloadBandwidth: &four,
3067                 TotalQPS:                  &totalQps,
3068         }
3069         err = client.SetBucketQoSInfo(bucketName, qosConfNo)
3070         c.Assert(err, IsNil)
3071
3072         // wait a moment for configuration effect
3073         time.Sleep(time.Second)
3074
3075         retQos, err = client.GetBucketQosInfo(bucketName)
3076         c.Assert(err, IsNil)
3077
3078         // set qosConfNo default value
3079         qosConfNo.XMLName.Local = "QoSConfiguration"
3080         defNum := -1
3081         qosConfNo.IntranetQPS = &defNum
3082         qosConfNo.ExtranetQPS = &defNum
3083         c.Assert(struct2string(retQos, c), Equals, struct2string(qosConfNo, c))
3084
3085         err = client.DeleteBucketQosInfo(bucketName)
3086         c.Assert(err, IsNil)
3087
3088         // wait a moment for configuration effect
3089         time.Sleep(time.Second)
3090
3091         _, err = client.GetBucketQosInfo(bucketName)
3092         c.Assert(err, NotNil)
3093
3094         // this is a error qos configuration
3095         to := *ret.TotalUploadBandwidth + 2
3096         qosErrConf := BucketQoSConfiguration{
3097                 TotalUploadBandwidth:      &to, // this exceed user TotalUploadBandwidth
3098                 IntranetUploadBandwidth:   &four,
3099                 ExtranetUploadBandwidth:   &four,
3100                 TotalDownloadBandwidth:    &four,
3101                 IntranetDownloadBandwidth: &four,
3102                 ExtranetDownloadBandwidth: &four,
3103                 TotalQPS:                  &totalQps,
3104                 IntranetQPS:               &totalQps,
3105                 ExtranetQPS:               &totalQps,
3106         }
3107         err = client.SetBucketQoSInfo(bucketName, qosErrConf)
3108         c.Assert(err, NotNil)
3109
3110         err = client.DeleteBucketQosInfo(bucketName)
3111         c.Assert(err, IsNil)
3112
3113         err = client.DeleteBucket(bucketName)
3114         c.Assert(err, IsNil)
3115 }
3116
3117 // struct to string
3118 func struct2string(obj interface{}, c *C) string {
3119         t := reflect.TypeOf(obj)
3120         v := reflect.ValueOf(obj)
3121
3122         var data = make(map[string]interface{})
3123         for i := 0; i < t.NumField(); i++ {
3124                 data[t.Field(i).Name] = v.Field(i).Interface()
3125         }
3126         str, err := json.Marshal(data)
3127         c.Assert(err, IsNil)
3128         return string(str)
3129 }
3130
3131 type TestCredentials struct {
3132 }
3133
3134 func (testCreInf *TestCredentials) GetAccessKeyID() string {
3135         return os.Getenv("OSS_TEST_ACCESS_KEY_ID")
3136 }
3137
3138 func (testCreInf *TestCredentials) GetAccessKeySecret() string {
3139         return os.Getenv("OSS_TEST_ACCESS_KEY_SECRET")
3140 }
3141
3142 func (testCreInf *TestCredentials) GetSecurityToken() string {
3143         return ""
3144 }
3145
3146 type TestCredentialsProvider struct {
3147 }
3148
3149 func (testInfBuild *TestCredentialsProvider) GetCredentials() Credentials {
3150         return &TestCredentials{}
3151 }
3152
3153 func (s *OssClientSuite) TestClientCredentialInfBuild(c *C) {
3154         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
3155         var defaultBuild TestCredentialsProvider
3156         client, err := New(endpoint, "", "", SetCredentialsProvider(&defaultBuild))
3157         c.Assert(err, IsNil)
3158         err = client.CreateBucket(bucketNameTest)
3159         c.Assert(err, IsNil)
3160         err = client.DeleteBucket(bucketNameTest)
3161         c.Assert(err, IsNil)
3162 }
3163
3164 func (s *OssClientSuite) TestClientSetLocalIpError(c *C) {
3165         // create client and bucket
3166         ipAddr, err := net.ResolveIPAddr("ip", "127.0.0.1")
3167         c.Assert(err, IsNil)
3168         localTCPAddr := &(net.TCPAddr{IP: ipAddr.IP})
3169         client, err := New(endpoint, accessID, accessKey, SetLocalAddr(localTCPAddr))
3170         c.Assert(err, IsNil)
3171
3172         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
3173         err = client.CreateBucket(bucketNameTest)
3174         c.Assert(err, NotNil)
3175 }
3176
3177 func (s *OssClientSuite) TestClientSetLocalIpSuccess(c *C) {
3178         //get local ip
3179         conn, err := net.Dial("udp", "8.8.8.8:80")
3180         c.Assert(err, IsNil)
3181         localAddr := conn.LocalAddr().(*net.UDPAddr)
3182         localIp := localAddr.IP.String()
3183         conn.Close()
3184
3185         ipAddr, err := net.ResolveIPAddr("ip", localIp)
3186         c.Assert(err, IsNil)
3187         localTCPAddr := &(net.TCPAddr{IP: ipAddr.IP})
3188         client, err := New(endpoint, accessID, accessKey, SetLocalAddr(localTCPAddr))
3189         c.Assert(err, IsNil)
3190
3191         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
3192         err = client.CreateBucket(bucketNameTest)
3193         c.Assert(err, IsNil)
3194         err = client.DeleteBucket(bucketNameTest)
3195         c.Assert(err, IsNil)
3196 }
3197
3198 // TestCreateBucketInvalidName
3199 func (s *OssClientSuite) TestCreateBucketInvalidName(c *C) {
3200         var bucketNameTest = "-" + bucketNamePrefix + RandLowStr(6)
3201         client, err := New(endpoint, accessID, accessKey)
3202         c.Assert(err, IsNil)
3203         // Create
3204         err = client.CreateBucket(bucketNameTest)
3205         c.Assert(err, NotNil)
3206 }
3207
3208 // TestClientProcessEndpointSuccess
3209 func (s *OssClientSuite) TestClientProcessEndpointSuccess(c *C) {
3210         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
3211
3212         testEndpoint := endpoint + "/" + "sina.com" + "?" + "para=abc"
3213
3214         client, err := New(testEndpoint, accessID, accessKey)
3215         c.Assert(err, IsNil)
3216
3217         // Create
3218         err = client.CreateBucket(bucketNameTest)
3219         c.Assert(err, IsNil)
3220
3221         // delete
3222         err = client.DeleteBucket(bucketNameTest)
3223         c.Assert(err, IsNil)
3224 }
3225
3226 // TestClientProcessEndpointSuccess
3227 func (s *OssClientSuite) TestClientProcessEndpointError(c *C) {
3228         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
3229
3230         testEndpoint := "https://127.0.0.1/" + endpoint
3231
3232         client, err := New(testEndpoint, accessID, accessKey)
3233         c.Assert(err, IsNil)
3234
3235         // Create
3236         err = client.CreateBucket(bucketNameTest)
3237         c.Assert(err, NotNil)
3238 }
3239
3240 // TestClientBucketError
3241 func (s *OssClientSuite) TestClientBucketError(c *C) {
3242         client, err := New(endpoint, accessID, accessKey)
3243         c.Assert(err, IsNil)
3244
3245         bucketName := "-" + RandLowStr(5)
3246         _, err = client.Bucket(bucketName)
3247         c.Assert(err, NotNil)
3248 }
3249
3250 func (s *OssClientSuite) TestSetBucketInventory(c *C) {
3251         client, err := New(endpoint, accessID, accessKey)
3252         c.Assert(err, IsNil)
3253
3254         bucketName := bucketNamePrefix + RandLowStr(5)
3255         err = client.CreateBucket(bucketName)
3256         c.Assert(err, IsNil)
3257
3258         // encryption config
3259         var invSseOss InvSseOss
3260         invSseKms := InvSseKms{
3261                 KmsId: "keyId",
3262         }
3263         var invEncryption InvEncryption
3264
3265         bl := true
3266         // not any encryption
3267         invConfig := InventoryConfiguration{
3268                 Id:        "report1",
3269                 IsEnabled: &bl,
3270                 Prefix:    "filterPrefix/",
3271                 OSSBucketDestination: OSSBucketDestination{
3272                         Format:    "CSV",
3273                         AccountId: accountID,
3274                         RoleArn:   stsARN,
3275                         Bucket:    "acs:oss:::" + bucketName,
3276                         Prefix:    "prefix1",
3277                 },
3278                 Frequency:              "Daily",
3279                 IncludedObjectVersions: "All",
3280                 OptionalFields: OptionalFields{
3281                         Field: []string{
3282                                 "Size", "LastModifiedDate", "ETag", "StorageClass", "IsMultipartUploaded", "EncryptionStatus",
3283                         },
3284                 },
3285         }
3286
3287         // case 1: not any encryption
3288         err = client.SetBucketInventory(bucketName, invConfig)
3289         c.Assert(err, IsNil)
3290
3291         // case 2: use kms encryption
3292         invConfig.Id = "report2"
3293         invEncryption.SseKms = &invSseKms
3294         invEncryption.SseOss = nil
3295         invConfig.OSSBucketDestination.Encryption = &invEncryption
3296         err = client.SetBucketInventory(bucketName, invConfig)
3297         c.Assert(err, IsNil)
3298
3299         // case 3: use SseOss encryption
3300         invConfig.Id = "report3"
3301         invEncryption.SseKms = nil
3302         invEncryption.SseOss = &invSseOss
3303         invConfig.OSSBucketDestination.Encryption = &invEncryption
3304         err = client.SetBucketInventory(bucketName, invConfig)
3305         c.Assert(err, IsNil)
3306
3307         //case 4: use two type encryption
3308         invConfig.Id = "report4"
3309         invEncryption.SseKms = &invSseKms
3310         invEncryption.SseOss = &invSseOss
3311         invConfig.OSSBucketDestination.Encryption = &invEncryption
3312         err = client.SetBucketInventory(bucketName, invConfig)
3313         c.Assert(err, NotNil)
3314
3315         err = client.DeleteBucket(bucketName)
3316         c.Assert(err, IsNil)
3317 }
3318
3319 func (s *OssClientSuite) TestBucketInventory(c *C) {
3320         client, err := New(endpoint, accessID, accessKey)
3321         c.Assert(err, IsNil)
3322
3323         bucketName := bucketNamePrefix + RandLowStr(5)
3324         err = client.CreateBucket(bucketName)
3325         c.Assert(err, IsNil)
3326
3327         bl := true
3328         invConfig := InventoryConfiguration{
3329                 Id:        "report1",
3330                 IsEnabled: &bl,
3331                 Prefix:    "filterPrefix/",
3332                 OSSBucketDestination: OSSBucketDestination{
3333                         Format:    "CSV",
3334                         AccountId: accountID,
3335                         RoleArn:   stsARN,
3336                         Bucket:    "acs:oss:::" + bucketName,
3337                         Prefix:    "prefix1",
3338                 },
3339                 Frequency:              "Daily",
3340                 IncludedObjectVersions: "All",
3341                 OptionalFields: OptionalFields{
3342                         Field: []string{
3343                                 "Size", "LastModifiedDate", "ETag", "StorageClass", "IsMultipartUploaded", "EncryptionStatus",
3344                         },
3345                 },
3346         }
3347
3348         // case 1: test SetBucketInventory
3349         err = client.SetBucketInventory(bucketName, invConfig)
3350         c.Assert(err, IsNil)
3351
3352         // case 2: test GetBucketInventory
3353         out, err := client.GetBucketInventory(bucketName, "report1")
3354         c.Assert(err, IsNil)
3355         invConfig.XMLName.Local = "InventoryConfiguration"
3356         invConfig.OSSBucketDestination.XMLName.Local = "OSSBucketDestination"
3357         invConfig.OptionalFields.XMLName.Local = "OptionalFields"
3358         c.Assert(struct2string(invConfig, c), Equals, struct2string(out, c))
3359
3360         // case 3: test ListBucketInventory
3361         invConfig2 := InventoryConfiguration{
3362                 Id:        "report2",
3363                 IsEnabled: &bl,
3364                 Prefix:    "filterPrefix/",
3365                 OSSBucketDestination: OSSBucketDestination{
3366                         Format:    "CSV",
3367                         AccountId: accountID,
3368                         RoleArn:   stsARN,
3369                         Bucket:    "acs:oss:::" + bucketName,
3370                         Prefix:    "prefix1",
3371                 },
3372                 Frequency:              "Daily",
3373                 IncludedObjectVersions: "All",
3374                 OptionalFields: OptionalFields{
3375                         Field: []string{
3376                                 "Size", "LastModifiedDate", "ETag", "StorageClass", "IsMultipartUploaded", "EncryptionStatus",
3377                         },
3378                 },
3379         }
3380         invConfig2.XMLName.Local = "InventoryConfiguration"
3381         invConfig2.OSSBucketDestination.XMLName.Local = "OSSBucketDestination"
3382         invConfig2.OptionalFields.XMLName.Local = "OptionalFields"
3383
3384         err = client.SetBucketInventory(bucketName, invConfig2)
3385         c.Assert(err, IsNil)
3386
3387         listInvConf, err := client.ListBucketInventory(bucketName, "", Marker("report1"), MaxKeys(2))
3388         c.Assert(err, IsNil)
3389         var listInvLocal ListInventoryConfigurationsResult
3390         listInvLocal.InventoryConfiguration = []InventoryConfiguration{
3391                 invConfig,
3392                 invConfig2,
3393         }
3394         bo := false
3395         listInvLocal.IsTruncated = &bo
3396         listInvLocal.XMLName.Local = "ListInventoryConfigurationsResult"
3397         c.Assert(struct2string(listInvLocal, c), Equals, struct2string(listInvConf, c))
3398
3399         for i := 3; i < 109; i++ {
3400                 invConfig2 := InventoryConfiguration{
3401                         Id:        "report" + strconv.Itoa(i),
3402                         IsEnabled: &bl,
3403                         Prefix:    "filterPrefix/",
3404                         OSSBucketDestination: OSSBucketDestination{
3405                                 Format:    "CSV",
3406                                 AccountId: accountID,
3407                                 RoleArn:   stsARN,
3408                                 Bucket:    "acs:oss:::" + bucketName,
3409                                 Prefix:    "prefix1",
3410                         },
3411                         Frequency:              "Daily",
3412                         IncludedObjectVersions: "All",
3413                         OptionalFields: OptionalFields{
3414                                 Field: []string{
3415                                         "Size", "LastModifiedDate", "ETag", "StorageClass", "IsMultipartUploaded", "EncryptionStatus",
3416                                 },
3417                         },
3418                 }
3419                 err = client.SetBucketInventory(bucketName, invConfig2)
3420                 c.Assert(err, IsNil)
3421         }
3422         token := ""
3423         for {
3424                 listInvConf1, err := client.ListBucketInventory(bucketName, token)
3425                 c.Assert(err, IsNil)
3426                 token = listInvConf1.NextContinuationToken
3427                 testLogger.Println(listInvConf1.NextContinuationToken, *listInvConf1.IsTruncated, token)
3428                 if *listInvConf1.IsTruncated == false {
3429                         break
3430                 } else {
3431                         c.Assert(listInvConf1.NextContinuationToken, Equals, "report91")
3432                 }
3433         }
3434
3435         // case 4: test DeleteBucketInventory
3436         for i := 1; i < 109; i++ {
3437                 err = client.DeleteBucketInventory(bucketName, "report"+strconv.Itoa(i))
3438                 c.Assert(err, IsNil)
3439         }
3440
3441         err = client.DeleteBucket(bucketName)
3442         c.Assert(err, IsNil)
3443 }
3444
3445 func (s *OssClientSuite) TestBucketInventoryNegative(c *C) {
3446         client, err := New(endpoint, accessID, accessKey)
3447         c.Assert(err, IsNil)
3448
3449         bucketName := bucketNamePrefix + RandLowStr(5)
3450         err = client.CreateBucket(bucketName)
3451         c.Assert(err, IsNil)
3452
3453         bl := true
3454         invConfigErr := InventoryConfiguration{
3455                 Id:        "report1",
3456                 IsEnabled: &bl,
3457                 Prefix:    "filterPrefix/",
3458                 OSSBucketDestination: OSSBucketDestination{
3459                         Format:    "CSV",
3460                         AccountId: accountID,
3461                         RoleArn:   stsARN,
3462                         Bucket:    "test",
3463                         Prefix:    "prefix1",
3464                 },
3465                 Frequency:              "Daily",
3466                 IncludedObjectVersions: "All",
3467                 OptionalFields: OptionalFields{
3468                         Field: []string{
3469                                 "Size", "LastModifiedDate", "ETag", "StorageClass", "IsMultipartUploaded", "EncryptionStatus",
3470                         },
3471                 },
3472         }
3473         // case 1: test SetBucketInventory
3474         err = client.SetBucketInventory(bucketName, invConfigErr)
3475         c.Assert(err, NotNil)
3476
3477         // case 2: test GetBucketInventory
3478         _, err = client.GetBucketInventory(bucketName, "report1")
3479         c.Assert(err, NotNil)
3480
3481         // case 3: test ListBucketInventory
3482         _, err = client.ListBucketInventory(bucketName, "", Marker("report1"), MaxKeys(2))
3483         c.Assert(err, NotNil)
3484
3485         // case 4: test DeleteBucketInventory
3486         err = client.DeleteBucketInventory(bucketName, "report1")
3487         c.Assert(err, IsNil)
3488
3489         err = client.DeleteBucket(bucketName)
3490         c.Assert(err, IsNil)
3491 }
3492
3493 func (s *OssClientSuite) TestBucketAsyncTask(c *C) {
3494         client, err := New(endpoint, accessID, accessKey)
3495         c.Assert(err, IsNil)
3496
3497         bucketName := bucketNamePrefix + RandLowStr(5)
3498         err = client.CreateBucket(bucketName)
3499         c.Assert(err, IsNil)
3500
3501         objectName := objectNamePrefix + RandLowStr(6)
3502
3503         // set asyn task,IgnoreSameKey is false
3504         asynConf := AsyncFetchTaskConfiguration{
3505                 Url:           "http://www.baidu.com",
3506                 Object:        objectName,
3507                 Host:          "",
3508                 ContentMD5:    "",
3509                 Callback:      "",
3510                 StorageClass:  "",
3511                 IgnoreSameKey: false,
3512         }
3513
3514         asynResult, err := client.SetBucketAsyncTask(bucketName, asynConf)
3515         c.Assert(err, IsNil)
3516         c.Assert(len(asynResult.TaskId) > 0, Equals, true)
3517
3518         // get asyn task
3519         asynTask, err := client.GetBucketAsyncTask(bucketName, asynResult.TaskId)
3520         c.Assert(err, IsNil)
3521         c.Assert(asynResult.TaskId, Equals, asynTask.TaskId)
3522         c.Assert(len(asynTask.State) > 0, Equals, true)
3523         c.Assert(asynConf.Url, Equals, asynTask.TaskInfo.Url)
3524         c.Assert(asynConf.Object, Equals, asynTask.TaskInfo.Object)
3525         c.Assert(asynConf.Callback, Equals, asynTask.TaskInfo.Callback)
3526         c.Assert(asynConf.IgnoreSameKey, Equals, asynTask.TaskInfo.IgnoreSameKey)
3527
3528         // test again,IgnoreSameKey is true
3529         asynConf.IgnoreSameKey = true
3530         asynResult, err = client.SetBucketAsyncTask(bucketName, asynConf)
3531         c.Assert(err, IsNil)
3532         c.Assert(len(asynResult.TaskId) > 0, Equals, true)
3533
3534         asynTask, err = client.GetBucketAsyncTask(bucketName, asynResult.TaskId)
3535         c.Assert(asynConf.IgnoreSameKey, Equals, asynTask.TaskInfo.IgnoreSameKey)
3536
3537         err = client.DeleteBucket(bucketName)
3538         c.Assert(err, IsNil)
3539 }
3540
3541 func (s *OssClientSuite) TestClientOptionHeader(c *C) {
3542         // create a bucket with default proprety
3543         client, err := New(endpoint, accessID, accessKey)
3544         c.Assert(err, IsNil)
3545
3546         bucketName := bucketNamePrefix + RandLowStr(6)
3547
3548         var respHeader http.Header
3549         err = client.CreateBucket(bucketName, GetResponseHeader(&respHeader))
3550         c.Assert(err, IsNil)
3551         c.Assert(GetRequestId(respHeader) != "", Equals, true)
3552
3553         // put bucket version:enabled
3554         var versioningConfig VersioningConfig
3555         versioningConfig.Status = string(VersionEnabled)
3556         err = client.SetBucketVersioning(bucketName, versioningConfig)
3557         c.Assert(err, IsNil)
3558
3559         // get bucket version success,use payer
3560         options := []Option{RequestPayer(BucketOwner), GetResponseHeader(&respHeader)}
3561         versioningResult, err := client.GetBucketVersioning(bucketName, options...)
3562         c.Assert(versioningResult.Status, Equals, "Enabled")
3563         c.Assert(GetRequestId(respHeader) != "", Equals, true)
3564
3565         //list buckets,use payer
3566         _, err = client.ListBuckets(options...)
3567         c.Assert(err, IsNil)
3568
3569         ForceDeleteBucket(client, bucketName, c)
3570 }
3571
3572 // compare with go1.7
3573 func compareVersion(goVersion string) bool {
3574         nowVersion := runtime.Version()
3575         nowVersion = strings.Replace(nowVersion, "go", "", -1)
3576         pSlice1 := strings.Split(goVersion, ".")
3577         pSlice2 := strings.Split(nowVersion, ".")
3578         for k, v := range pSlice2 {
3579                 n2, _ := strconv.Atoi(string(v))
3580                 n1, _ := strconv.Atoi(string(pSlice1[k]))
3581                 if n2 > n1 {
3582                         return true
3583                 }
3584                 if n2 < n1 {
3585                         return false
3586                 }
3587         }
3588         return true
3589 }
3590
3591 func homeHandler(w http.ResponseWriter, r *http.Request) {
3592         http.Redirect(w, r, "/redirectTo", http.StatusFound)
3593 }
3594 func targetHandler(w http.ResponseWriter, r *http.Request) {
3595         fmt.Fprintf(w, "You have been redirected here!")
3596 }
3597
3598 func (s *OssClientSuite) TestClientRedirect(c *C) {
3599         // must go1.7.0 onward
3600         if !compareVersion("1.7.0") {
3601                 return
3602         }
3603
3604         // get port
3605         rand.Seed(time.Now().Unix())
3606         port := 10000 + rand.Intn(10000)
3607
3608         // start http server
3609         httpAddr := fmt.Sprintf("127.0.0.1:%d", port)
3610         mux := http.NewServeMux()
3611         mux.HandleFunc("/redirectTo", targetHandler)
3612         mux.HandleFunc("/", homeHandler)
3613         svr := &http.Server{
3614                 Addr:           httpAddr,
3615                 ReadTimeout:    10 * time.Second,
3616                 WriteTimeout:   10 * time.Second,
3617                 MaxHeaderBytes: 1 << 20,
3618                 Handler:        mux,
3619         }
3620
3621         go func() {
3622                 svr.ListenAndServe()
3623         }()
3624
3625         url := "http://" + httpAddr
3626
3627         // create client 1,redirect disable
3628         client1, err := New(endpoint, accessID, accessKey, RedirectEnabled(false))
3629         resp, err := client1.Conn.client.Get(url)
3630         c.Assert(err, IsNil)
3631         c.Assert(resp.StatusCode, Equals, http.StatusFound)
3632         resp.Body.Close()
3633
3634         // create client2, redirect enabled
3635         client2, err := New(endpoint, accessID, accessKey, RedirectEnabled(true))
3636         resp, err = client2.Conn.client.Get(url)
3637         c.Assert(err, IsNil)
3638         c.Assert(resp.StatusCode, Equals, 200)
3639         data, err := ioutil.ReadAll(resp.Body)
3640         c.Assert(string(data), Equals, "You have been redirected here!")
3641         resp.Body.Close()
3642 }
3643
3644 // TestInitiateBucketWormSuccess
3645 func (s *OssClientSuite) TestInitiateBucketWormSuccess(c *C) {
3646         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
3647         client, err := New(endpoint, accessID, accessKey)
3648         c.Assert(err, IsNil)
3649
3650         err = client.CreateBucket(bucketNameTest)
3651         c.Assert(err, IsNil)
3652
3653         // InitiateBucketWorm
3654         wormId, err := client.InitiateBucketWorm(bucketNameTest, 10)
3655         c.Assert(err, IsNil)
3656         c.Assert(len(wormId) > 0, Equals, true)
3657
3658         // GetBucketWorm
3659         wormConfig, err := client.GetBucketWorm(bucketNameTest)
3660         c.Assert(err, IsNil)
3661         c.Assert(wormConfig.WormId, Equals, wormId)
3662         c.Assert(wormConfig.State, Equals, "InProgress")
3663         c.Assert(wormConfig.RetentionPeriodInDays, Equals, 10)
3664
3665         err = client.DeleteBucket(bucketNameTest)
3666         c.Assert(err, IsNil)
3667 }
3668
3669 // TestInitiateBucketWormFailure
3670 func (s *OssClientSuite) TestInitiateBucketWormFailure(c *C) {
3671         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
3672         client, err := New(endpoint, accessID, accessKey)
3673         c.Assert(err, IsNil)
3674
3675         // bucket not exist
3676         wormId, err := client.InitiateBucketWorm(bucketNameTest, 10)
3677         c.Assert(err, NotNil)
3678         c.Assert(len(wormId), Equals, 0)
3679 }
3680
3681 // TestAbortBucketWorm
3682 func (s *OssClientSuite) TestAbortBucketWorm(c *C) {
3683         var bucketNameTest = bucketNamePrefix + RandLowStr(6)
3684         client, err := New(endpoint, accessID, accessKey)
3685         c.Assert(err, IsNil)
3686
3687         err = client.CreateBucket(bucketNameTest)
3688         c.Assert(err, IsNil)
3689
3690         // InitiateBucketWorm
3691         wormId, err := client.InitiateBucketWorm(bucketNameTest, 10)
3692         c.Assert(err, IsNil)
3693         c.Assert(len(wormId) > 0, Equals, true)
3694
3695         // GetBucketWorm success
3696         wormConfig, err := client.GetBucketWorm(bucketNameTest)
3697         c.Assert(err, IsNil)
3698         c.Assert(wormConfig.WormId, Equals, wormId)
3699         c.Assert(wormConfig.State, Equals, "InProgress")
3700         c.Assert(wormConfig.RetentionPeriodInDays, Equals, 10)
3701
3702         // abort worm
3703         err = client.AbortBucketWorm(bucketNameTest)
3704         c.Assert(err, IsNil)
3705
3706         // GetBucketWorm failure
3707         _, err = client.GetBucketWorm(bucketNameTest)
3708         c.Assert(err, NotNil)
3709
3710         err = client.DeleteBucket(bucketNameTest)
3711         c.Assert(err, IsNil)
3712 }
3713
3714 // TestCompleteBucketWorm
3715 func (s *OssClientSuite) TestCompleteBucketWorm(c *C) {
3716         var bucketNameTest = bucketNamePrefix + "-worm-" + RandLowStr(6)
3717         client, err := New(endpoint, accessID, accessKey)
3718         c.Assert(err, IsNil)
3719
3720         err = client.CreateBucket(bucketNameTest)
3721         c.Assert(err, IsNil)
3722
3723         // InitiateBucketWorm
3724         wormId, err := client.InitiateBucketWorm(bucketNameTest, 1)
3725         c.Assert(err, IsNil)
3726         c.Assert(len(wormId) > 0, Equals, true)
3727
3728         // GetBucketWorm
3729         wormConfig, err := client.GetBucketWorm(bucketNameTest)
3730         c.Assert(err, IsNil)
3731         c.Assert(wormConfig.WormId, Equals, wormId)
3732         c.Assert(wormConfig.State, Equals, "InProgress")
3733         c.Assert(wormConfig.RetentionPeriodInDays, Equals, 1)
3734
3735         // CompleteBucketWorm
3736         err = client.CompleteBucketWorm(bucketNameTest, wormId)
3737         c.Assert(err, IsNil)
3738
3739         // GetBucketWorm again
3740         wormConfig, err = client.GetBucketWorm(bucketNameTest)
3741         c.Assert(err, IsNil)
3742         c.Assert(wormConfig.WormId, Equals, wormId)
3743         c.Assert(wormConfig.State, Equals, "Locked")
3744         c.Assert(wormConfig.RetentionPeriodInDays, Equals, 1)
3745
3746         err = client.DeleteBucket(bucketNameTest)
3747         c.Assert(err, IsNil)
3748 }
3749
3750 // TestExtendBucketWorm
3751 func (s *OssClientSuite) TestExtendBucketWorm(c *C) {
3752         var bucketNameTest = bucketNamePrefix + "-worm-" + RandLowStr(6)
3753         client, err := New(endpoint, accessID, accessKey)
3754         c.Assert(err, IsNil)
3755
3756         err = client.CreateBucket(bucketNameTest)
3757         c.Assert(err, IsNil)
3758
3759         // InitiateBucketWorm
3760         wormId, err := client.InitiateBucketWorm(bucketNameTest, 1)
3761         c.Assert(err, IsNil)
3762         c.Assert(len(wormId) > 0, Equals, true)
3763
3764         // CompleteBucketWorm
3765         err = client.CompleteBucketWorm(bucketNameTest, wormId)
3766         c.Assert(err, IsNil)
3767
3768         // GetBucketWorm
3769         wormConfig, err := client.GetBucketWorm(bucketNameTest)
3770         c.Assert(err, IsNil)
3771         c.Assert(wormConfig.WormId, Equals, wormId)
3772         c.Assert(wormConfig.State, Equals, "Locked")
3773         c.Assert(wormConfig.RetentionPeriodInDays, Equals, 1)
3774
3775         // CompleteBucketWorm
3776         err = client.ExtendBucketWorm(bucketNameTest, 2, wormId)
3777         c.Assert(err, IsNil)
3778
3779         // GetBucketWorm again
3780         wormConfig, err = client.GetBucketWorm(bucketNameTest)
3781         c.Assert(err, IsNil)
3782         c.Assert(wormConfig.WormId, Equals, wormId)
3783         c.Assert(wormConfig.State, Equals, "Locked")
3784         c.Assert(wormConfig.RetentionPeriodInDays, Equals, 2)
3785
3786         err = client.DeleteBucket(bucketNameTest)
3787         c.Assert(err, IsNil)
3788 }