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

   1 // Credentials test
   2 package oss
   3
   4 import (
   5         "bytes"
   6         "io/ioutil"
   7         "math/rand"
   8         "os"
   9         "strconv"
  10         "strings"
  11
  12         . "gopkg.in/check.v1"
  13 )
  14
  15 type OssCredentialBucketSuite struct {
  16         client    *Client
  17         creClient *Client
  18         bucket    *Bucket
  19         creBucket *Bucket
  20 }
  21
  22 var _ = Suite(&OssCredentialBucketSuite{})
  23
  24 func (cs *OssCredentialBucketSuite) credentialSubUser(c *C) {
  25         client, err := New(endpoint, accessID, accessKey)
  26         c.Assert(err, IsNil)
  27         err = client.CreateBucket(credentialBucketName)
  28         c.Assert(err, IsNil)
  29         cs.client = client
  30         policyInfo := `
  31         {
  32                 "Version":"1",
  33                 "Statement":[
  34                         {
  35                                 "Action":[
  36                                         "oss:*"
  37                                 ],
  38                                 "Effect":"Allow",
  39                                 "Principal":["` + credentialUID + `"],
  40                                 "Resource":["acs:oss:*:*:` + credentialBucketName + `", "acs:oss:*:*:` + credentialBucketName + `/*"]
  41                         }
  42                 ]
  43         }`
  44
  45         err = client.SetBucketPolicy(credentialBucketName, policyInfo)
  46         c.Assert(err, IsNil)
  47
  48         bucket, err := cs.client.Bucket(credentialBucketName)
  49         c.Assert(err, IsNil)
  50         cs.bucket = bucket
  51 }
  52
  53 // SetUpSuite runs once when the suite starts running.
  54 func (cs *OssCredentialBucketSuite) SetUpSuite(c *C) {
  55         if credentialUID == "" {
  56                 testLogger.Println("the cerdential UID is NULL, skip the credential test")
  57                 c.Skip("the credential Uid is null")
  58         }
  59
  60         cs.credentialSubUser(c)
  61         client, err := New(endpoint, credentialAccessID, credentialAccessKey)
  62         c.Assert(err, IsNil)
  63         cs.creClient = client
  64
  65         bucket, err := cs.creClient.Bucket(credentialBucketName)
  66         c.Assert(err, IsNil)
  67         cs.creBucket = bucket
  68
  69         testLogger.Println("test credetial bucket started")
  70 }
  71
  72 func (cs *OssCredentialBucketSuite) TearDownSuite(c *C) {
  73         if credentialUID == "" {
  74                 c.Skip("the credential Uid is null")
  75         }
  76         for _, bucket := range []*Bucket{cs.bucket} {
  77                 // Delete multipart
  78                 keyMarker := KeyMarker("")
  79                 uploadIDMarker := UploadIDMarker("")
  80                 for {
  81                         lmu, err := bucket.ListMultipartUploads(keyMarker, uploadIDMarker)
  82                         c.Assert(err, IsNil)
  83                         for _, upload := range lmu.Uploads {
  84                                 imur := InitiateMultipartUploadResult{Bucket: credentialBucketName, Key: upload.Key, UploadID: upload.UploadID}
  85                                 err = bucket.AbortMultipartUpload(imur)
  86                                 c.Assert(err, IsNil)
  87                         }
  88                         keyMarker = KeyMarker(lmu.NextKeyMarker)
  89                         uploadIDMarker = UploadIDMarker(lmu.NextUploadIDMarker)
  90                         if !lmu.IsTruncated {
  91                                 break
  92                         }
  93                 }
  94                 // Delete objects
  95                 marker := Marker("")
  96                 for {
  97                         lor, err := bucket.ListObjects(marker)
  98                         c.Assert(err, IsNil)
  99                         for _, object := range lor.Objects {
 100                                 err = bucket.DeleteObject(object.Key)
 101                                 c.Assert(err, IsNil)
 102                         }
 103                         marker = Marker(lor.NextMarker)
 104                         if !lor.IsTruncated {
 105                                 break
 106                         }
 107                 }
 108         }
 109         err := cs.client.DeleteBucket(credentialBucketName)
 110         c.Assert(err, IsNil)
 111         testLogger.Println("test credential bucket completed")
 112 }
 113
 114 // Test put/get/list/delte object
 115 func (cs *OssCredentialBucketSuite) TestReqerPaymentNoRequester(c *C) {
 116         // Set bucket is requester who send the request
 117         reqPayConf := RequestPaymentConfiguration{
 118                 Payer: string(Requester),
 119         }
 120         err := cs.client.SetBucketRequestPayment(credentialBucketName, reqPayConf)
 121         c.Assert(err, IsNil)
 122
 123         key := objectNamePrefix + RandStr(8)
 124         objectValue := RandStr(18)
 125
 126         // Put object
 127         err = cs.creBucket.PutObject(key, strings.NewReader(objectValue))
 128         c.Assert(err, NotNil)
 129
 130         // Get object
 131         _, err = cs.creBucket.GetObject(key)
 132         c.Assert(err, NotNil)
 133
 134         // List object
 135         _, err = cs.creBucket.ListObjects()
 136         c.Assert(err, NotNil)
 137
 138         err = cs.creBucket.DeleteObject(key)
 139         c.Assert(err, NotNil)
 140
 141         // Set bucket is BucketOwner
 142         reqPayConf.Payer = string(BucketOwner)
 143         err = cs.client.SetBucketRequestPayment(credentialBucketName, reqPayConf)
 144         c.Assert(err, IsNil)
 145 }
 146
 147 // Test put/get/list/delte object
 148 func (cs *OssCredentialBucketSuite) TestReqerPaymentWithRequester(c *C) {
 149         // Set bucket is requester who send the request
 150         reqPayConf := RequestPaymentConfiguration{
 151                 Payer: string(Requester),
 152         }
 153         err := cs.client.SetBucketRequestPayment(credentialBucketName, reqPayConf)
 154         c.Assert(err, IsNil)
 155
 156         key := objectNamePrefix + RandStr(8)
 157         objectValue := RandStr(18)
 158
 159         // Put object with a bucketowner
 160         err = cs.creBucket.PutObject(key, strings.NewReader(objectValue), RequestPayer(BucketOwner))
 161         c.Assert(err, NotNil)
 162
 163         // Put object
 164         err = cs.creBucket.PutObject(key, strings.NewReader(objectValue), RequestPayer(Requester))
 165         c.Assert(err, IsNil)
 166
 167         // Get object
 168         body, err := cs.creBucket.GetObject(key, RequestPayer(Requester))
 169         c.Assert(err, IsNil)
 170         defer body.Close()
 171
 172         data, err := ioutil.ReadAll(body)
 173         c.Assert(err, IsNil)
 174         c.Assert(string(data), Equals, objectValue)
 175
 176         // List object
 177         lor, err := cs.creBucket.ListObjects(RequestPayer(Requester))
 178         c.Assert(err, IsNil)
 179         c.Assert(len(lor.Objects), Equals, 1)
 180
 181         err = cs.creBucket.DeleteObject(key, RequestPayer(Requester))
 182         c.Assert(err, IsNil)
 183
 184         // Set bucket is BucketOwner
 185         reqPayConf.Payer = string(BucketOwner)
 186         err = cs.client.SetBucketRequestPayment(credentialBucketName, reqPayConf)
 187         c.Assert(err, IsNil)
 188 }
 189
 190 // Test put/get/list/delte object
 191 func (cs *OssCredentialBucketSuite) TestOwnerPaymentNoRequester(c *C) {
 192         // Set bucket is requester who send the request
 193         reqPayConf := RequestPaymentConfiguration{
 194                 Payer: string(BucketOwner),
 195         }
 196         err := cs.client.SetBucketRequestPayment(credentialBucketName, reqPayConf)
 197         c.Assert(err, IsNil)
 198
 199         key := objectNamePrefix + RandStr(8)
 200         objectValue := RandStr(18)
 201
 202         // Put object
 203         err = cs.creBucket.PutObject(key, strings.NewReader(objectValue))
 204         c.Assert(err, IsNil)
 205
 206         // Get object
 207         body, err := cs.creBucket.GetObject(key)
 208         c.Assert(err, IsNil)
 209         defer body.Close()
 210
 211         data, err := ioutil.ReadAll(body)
 212         c.Assert(err, IsNil)
 213         c.Assert(string(data), Equals, objectValue)
 214
 215         // List object
 216         lor, err := cs.creBucket.ListObjects()
 217         c.Assert(err, IsNil)
 218         c.Assert(len(lor.Objects), Equals, 1)
 219
 220         err = cs.creBucket.DeleteObject(key)
 221         c.Assert(err, IsNil)
 222 }
 223
 224 // Test put/get/list/delte object
 225 func (cs *OssCredentialBucketSuite) TestOwnerPaymentWithRequester(c *C) {
 226         // Set bucket is BucketOwner payer
 227         reqPayConf := RequestPaymentConfiguration{
 228                 Payer: string(BucketOwner),
 229         }
 230
 231         err := cs.client.SetBucketRequestPayment(credentialBucketName, reqPayConf)
 232         c.Assert(err, IsNil)
 233
 234         key := objectNamePrefix + RandStr(8)
 235         objectValue := RandStr(18)
 236
 237         // Put object
 238         err = cs.creBucket.PutObject(key, strings.NewReader(objectValue), RequestPayer(BucketOwner))
 239         c.Assert(err, IsNil)
 240
 241         // Put object
 242         err = cs.creBucket.PutObject(key, strings.NewReader(objectValue), RequestPayer(Requester))
 243         c.Assert(err, IsNil)
 244
 245         // Get object
 246         body, err := cs.creBucket.GetObject(key, RequestPayer(Requester))
 247         c.Assert(err, IsNil)
 248         defer body.Close()
 249
 250         data, err := ioutil.ReadAll(body)
 251         c.Assert(err, IsNil)
 252         c.Assert(string(data), Equals, objectValue)
 253
 254         // List object
 255         lor, err := cs.creBucket.ListObjects(RequestPayer(Requester))
 256         c.Assert(err, IsNil)
 257         c.Assert(len(lor.Objects), Equals, 1)
 258
 259         err = cs.creBucket.DeleteObject(key, RequestPayer(Requester))
 260         c.Assert(err, IsNil)
 261 }
 262
 263 // TestPutObjectFromFile
 264 func (cs *OssCredentialBucketSuite) TestPutObjectFromFile(c *C) {
 265         objectName := objectNamePrefix + RandStr(8)
 266         localFile := "../sample/BingWallpaper-2015-11-07.jpg"
 267         newFile := RandStr(8) + ".jpg"
 268
 269         // Put
 270         err := cs.creBucket.PutObjectFromFile(objectName, localFile, RequestPayer(Requester))
 271         c.Assert(err, IsNil)
 272
 273         // Check
 274         err = cs.creBucket.GetObjectToFile(objectName, newFile, RequestPayer(Requester))
 275         c.Assert(err, IsNil)
 276         eq, err := compareFiles(localFile, newFile)
 277         c.Assert(err, IsNil)
 278         c.Assert(eq, Equals, true)
 279
 280         meta, err := cs.creBucket.GetObjectDetailedMeta(objectName, RequestPayer(Requester))
 281         c.Assert(err, IsNil)
 282         c.Assert(meta.Get("Content-Type"), Equals, "image/jpeg")
 283
 284         acl, err := cs.creBucket.GetObjectACL(objectName, RequestPayer(Requester))
 285         c.Assert(err, IsNil)
 286         testLogger.Println("aclRes:", acl)
 287         c.Assert(acl.ACL, Equals, "default")
 288
 289         err = cs.creBucket.DeleteObject(objectName, RequestPayer(Requester))
 290         c.Assert(err, IsNil)
 291
 292         // Put with properties
 293         options := []Option{
 294                 Expires(futureDate),
 295                 ObjectACL(ACLPublicRead),
 296                 Meta("myprop", "mypropval"),
 297                 RequestPayer(Requester),
 298         }
 299         err = cs.creBucket.PutObjectFromFile(objectName, localFile, options...)
 300         c.Assert(err, IsNil)
 301
 302         // Check
 303         err = cs.creBucket.GetObjectToFile(objectName, newFile, RequestPayer(Requester))
 304         c.Assert(err, IsNil)
 305         eq, err = compareFiles(localFile, newFile)
 306         c.Assert(err, IsNil)
 307         c.Assert(eq, Equals, true)
 308
 309         acl, err = cs.creBucket.GetObjectACL(objectName, RequestPayer(Requester))
 310         c.Assert(err, IsNil)
 311         testLogger.Println("GetObjectACL:", acl)
 312         c.Assert(acl.ACL, Equals, string(ACLPublicRead))
 313
 314         meta, err = cs.creBucket.GetObjectDetailedMeta(objectName, RequestPayer(Requester))
 315         c.Assert(err, IsNil)
 316         testLogger.Println("GetObjectDetailedMeta:", meta)
 317         c.Assert(meta.Get("X-Oss-Meta-Myprop"), Equals, "mypropval")
 318
 319         err = cs.creBucket.DeleteObject(objectName, RequestPayer(Requester))
 320         c.Assert(err, IsNil)
 321         os.Remove(newFile)
 322 }
 323
 324 // TestCopyObject
 325 func (cs *OssCredentialBucketSuite) TestCopyObject(c *C) {
 326         objectName := objectNamePrefix + RandStr(8)
 327         objectValue := RandStr(18)
 328
 329         err := cs.creBucket.PutObject(objectName, strings.NewReader(objectValue),
 330                 ACL(ACLPublicRead), Meta("my", "myprop"), RequestPayer(Requester))
 331         c.Assert(err, IsNil)
 332
 333         // Copy
 334         var objectNameDest = objectName + "dest"
 335         _, err = cs.creBucket.CopyObject(objectName, objectNameDest, RequestPayer(Requester))
 336         c.Assert(err, IsNil)
 337
 338         // Check
 339         lor, err := cs.creBucket.ListObjects(Prefix(objectName), RequestPayer(Requester))
 340         c.Assert(err, IsNil)
 341         testLogger.Println("objects:", lor.Objects)
 342         c.Assert(len(lor.Objects), Equals, 2)
 343
 344         body, err := cs.creBucket.GetObject(objectName, RequestPayer(Requester))
 345         c.Assert(err, IsNil)
 346         str, err := readBody(body)
 347         c.Assert(err, IsNil)
 348         c.Assert(str, Equals, objectValue)
 349
 350         err = cs.creBucket.DeleteObject(objectNameDest, RequestPayer(Requester))
 351         c.Assert(err, IsNil)
 352
 353         // Copy with constraints x-oss-copy-source-if-modified-since
 354         _, err = cs.creBucket.CopyObject(objectName, objectNameDest, CopySourceIfModifiedSince(futureDate), RequestPayer(Requester))
 355         c.Assert(err, NotNil)
 356         testLogger.Println("CopyObject:", err)
 357
 358         // Copy with constraints x-oss-copy-source-if-unmodified-since
 359         _, err = cs.creBucket.CopyObject(objectName, objectNameDest, CopySourceIfUnmodifiedSince(futureDate), RequestPayer(Requester))
 360         c.Assert(err, IsNil)
 361
 362         // Check
 363         lor, err = cs.creBucket.ListObjects(Prefix(objectName), RequestPayer(Requester))
 364         c.Assert(err, IsNil)
 365         testLogger.Println("objects:", lor.Objects)
 366         c.Assert(len(lor.Objects), Equals, 2)
 367
 368         body, err = cs.creBucket.GetObject(objectName, RequestPayer(Requester))
 369         c.Assert(err, IsNil)
 370         str, err = readBody(body)
 371         c.Assert(err, IsNil)
 372         c.Assert(str, Equals, objectValue)
 373
 374         err = cs.creBucket.DeleteObject(objectNameDest, RequestPayer(Requester))
 375         c.Assert(err, IsNil)
 376
 377         // Copy with constraints x-oss-copy-source-if-match
 378         meta, err := cs.creBucket.GetObjectDetailedMeta(objectName, RequestPayer(Requester))
 379         c.Assert(err, IsNil)
 380         testLogger.Println("GetObjectDetailedMeta:", meta)
 381
 382         _, err = cs.creBucket.CopyObject(objectName, objectNameDest, CopySourceIfMatch(meta.Get("Etag")), RequestPayer(Requester))
 383         c.Assert(err, IsNil)
 384
 385         // Check
 386         body, err = cs.creBucket.GetObject(objectName, RequestPayer(Requester))
 387         c.Assert(err, IsNil)
 388         str, err = readBody(body)
 389         c.Assert(err, IsNil)
 390         c.Assert(str, Equals, objectValue)
 391
 392         err = cs.creBucket.DeleteObject(objectNameDest, RequestPayer(Requester))
 393         c.Assert(err, IsNil)
 394
 395         // Copy with constraints x-oss-copy-source-if-none-match
 396         _, err = cs.creBucket.CopyObject(objectName, objectNameDest, CopySourceIfNoneMatch(meta.Get("Etag")), RequestPayer(Requester))
 397         c.Assert(err, NotNil)
 398
 399         // Copy with constraints x-oss-metadata-directive
 400         _, err = cs.creBucket.CopyObject(objectName, objectNameDest, Meta("my", "mydestprop"),
 401                 MetadataDirective(MetaCopy), RequestPayer(Requester))
 402         c.Assert(err, IsNil)
 403
 404         // Check
 405         body, err = cs.creBucket.GetObject(objectName, RequestPayer(Requester))
 406         c.Assert(err, IsNil)
 407         str, err = readBody(body)
 408         c.Assert(err, IsNil)
 409         c.Assert(str, Equals, objectValue)
 410
 411         destMeta, err := cs.creBucket.GetObjectDetailedMeta(objectNameDest, RequestPayer(Requester))
 412         c.Assert(err, IsNil)
 413         c.Assert(meta.Get("X-Oss-Meta-My"), Equals, "myprop")
 414
 415         acl, err := cs.creBucket.GetObjectACL(objectNameDest, RequestPayer(Requester))
 416         c.Assert(err, IsNil)
 417         c.Assert(acl.ACL, Equals, "default")
 418
 419         err = cs.creBucket.DeleteObject(objectNameDest, RequestPayer(Requester))
 420         c.Assert(err, IsNil)
 421
 422         // Copy with constraints x-oss-metadata-directive and self defined dest object meta
 423         options := []Option{
 424                 ObjectACL(ACLPublicReadWrite),
 425                 Meta("my", "mydestprop"),
 426                 MetadataDirective(MetaReplace),
 427                 RequestPayer(Requester),
 428         }
 429         _, err = cs.creBucket.CopyObject(objectName, objectNameDest, options...)
 430         c.Assert(err, IsNil)
 431
 432         // Check
 433         body, err = cs.creBucket.GetObject(objectName, RequestPayer(Requester))
 434         c.Assert(err, IsNil)
 435         str, err = readBody(body)
 436         c.Assert(err, IsNil)
 437         c.Assert(str, Equals, objectValue)
 438
 439         destMeta, err = cs.creBucket.GetObjectDetailedMeta(objectNameDest, RequestPayer(Requester))
 440         c.Assert(err, IsNil)
 441         c.Assert(destMeta.Get("X-Oss-Meta-My"), Equals, "mydestprop")
 442
 443         acl, err = cs.creBucket.GetObjectACL(objectNameDest, RequestPayer(Requester))
 444         c.Assert(err, IsNil)
 445         c.Assert(acl.ACL, Equals, string(ACLPublicReadWrite))
 446
 447         err = cs.creBucket.DeleteObject(objectNameDest, RequestPayer(Requester))
 448         c.Assert(err, IsNil)
 449
 450         err = cs.creBucket.DeleteObject(objectName, RequestPayer(Requester))
 451         c.Assert(err, IsNil)
 452 }
 453
 454 // TestCopyObjectToOrFrom
 455 func (cs *OssCredentialBucketSuite) TestCopyObjectToOrFrom(c *C) {
 456         objectName := objectNamePrefix + RandStr(8)
 457         objectValue := RandStr(18)
 458         sorBucketName := credentialBucketName + "-sor"
 459         objectNameDest := objectName + "-Dest"
 460
 461         err := cs.client.CreateBucket(sorBucketName)
 462         c.Assert(err, IsNil)
 463         // Set ACL_PUBLIC_R
 464         err = cs.client.SetBucketACL(sorBucketName, ACLPublicRead)
 465         c.Assert(err, IsNil)
 466
 467         sorBucket, err := cs.client.Bucket(sorBucketName)
 468         c.Assert(err, IsNil)
 469
 470         err = sorBucket.PutObject(objectName, strings.NewReader(objectValue))
 471         c.Assert(err, IsNil)
 472
 473         // Copy from
 474         _, err = cs.creBucket.CopyObjectFrom(sorBucketName, objectName, objectNameDest, RequestPayer(Requester))
 475         c.Assert(err, IsNil)
 476
 477         // Check
 478         body, err := cs.creBucket.GetObject(objectNameDest, RequestPayer(Requester))
 479         c.Assert(err, IsNil)
 480         str, err := readBody(body)
 481         c.Assert(err, IsNil)
 482         c.Assert(str, Equals, objectValue)
 483
 484         err = cs.creBucket.DeleteObject(objectNameDest, RequestPayer(Requester))
 485         c.Assert(err, IsNil)
 486
 487         // Copy to
 488         _, err = sorBucket.CopyObjectTo(credentialBucketName, objectName, objectName)
 489         c.Assert(err, IsNil)
 490
 491         // Check
 492         body, err = cs.creBucket.GetObject(objectName, RequestPayer(Requester))
 493         c.Assert(err, IsNil)
 494         str, err = readBody(body)
 495         c.Assert(err, IsNil)
 496         c.Assert(str, Equals, objectValue)
 497
 498         // Clean
 499         err = sorBucket.DeleteObject(objectName)
 500         c.Assert(err, IsNil)
 501
 502         err = cs.creBucket.DeleteObject(objectName, RequestPayer(Requester))
 503         c.Assert(err, IsNil)
 504
 505         err = cs.client.DeleteBucket(sorBucketName)
 506         c.Assert(err, IsNil)
 507 }
 508
 509 // TestAppendObject
 510 func (cs *OssCredentialBucketSuite) TestAppendObject(c *C) {
 511         objectName := objectNamePrefix + RandStr(8)
 512         objectValue1 := RandStr(18)
 513         objectValue2 := RandStr(18)
 514         objectValue := objectValue1 + objectValue2
 515         var val = []byte(objectValue)
 516         var localFile = RandStr(8) + ".txt"
 517         var nextPos int64
 518         var midPos = 1 + rand.Intn(len(val)-1)
 519
 520         var err = CreateFileAndWrite(localFile+"1", val[0:midPos])
 521         c.Assert(err, IsNil)
 522         err = CreateFileAndWrite(localFile+"2", val[midPos:])
 523         c.Assert(err, IsNil)
 524
 525         // String append
 526         nextPos, err = cs.creBucket.AppendObject(objectName, strings.NewReader(objectValue1), nextPos, RequestPayer(Requester))
 527         c.Assert(err, IsNil)
 528         nextPos, err = cs.creBucket.AppendObject(objectName, strings.NewReader(objectValue2), nextPos, RequestPayer(Requester))
 529         c.Assert(err, IsNil)
 530
 531         body, err := cs.creBucket.GetObject(objectName, RequestPayer(Requester))
 532         c.Assert(err, IsNil)
 533         str, err := readBody(body)
 534         c.Assert(err, IsNil)
 535         c.Assert(str, Equals, objectValue)
 536
 537         err = cs.creBucket.DeleteObject(objectName, RequestPayer(Requester))
 538         c.Assert(err, IsNil)
 539
 540         // Byte append
 541         nextPos = 0
 542         nextPos, err = cs.creBucket.AppendObject(objectName, bytes.NewReader(val[0:midPos]), nextPos, RequestPayer(Requester))
 543         c.Assert(err, IsNil)
 544         nextPos, err = cs.creBucket.AppendObject(objectName, bytes.NewReader(val[midPos:]), nextPos, RequestPayer(Requester))
 545         c.Assert(err, IsNil)
 546
 547         body, err = cs.creBucket.GetObject(objectName, RequestPayer(Requester))
 548         c.Assert(err, IsNil)
 549         str, err = readBody(body)
 550         c.Assert(err, IsNil)
 551         c.Assert(str, Equals, objectValue)
 552
 553         err = cs.creBucket.DeleteObject(objectName, RequestPayer(Requester))
 554         c.Assert(err, IsNil)
 555
 556         // File append
 557         options := []Option{
 558                 ObjectACL(ACLPublicReadWrite),
 559                 Meta("my", "myprop"),
 560                 RequestPayer(Requester),
 561         }
 562
 563         fd, err := os.Open(localFile + "1")
 564         c.Assert(err, IsNil)
 565         defer fd.Close()
 566         nextPos = 0
 567         nextPos, err = cs.creBucket.AppendObject(objectName, fd, nextPos, options...)
 568         c.Assert(err, IsNil)
 569
 570         meta, err := cs.creBucket.GetObjectDetailedMeta(objectName, RequestPayer(Requester))
 571         c.Assert(err, IsNil)
 572         testLogger.Println("GetObjectDetailedMeta:", meta, ",", nextPos)
 573         c.Assert(meta.Get("X-Oss-Object-Type"), Equals, "Appendable")
 574         c.Assert(meta.Get("X-Oss-Meta-My"), Equals, "myprop")
 575         c.Assert(meta.Get("x-oss-Meta-Mine"), Equals, "")
 576         c.Assert(meta.Get("X-Oss-Next-Append-Position"), Equals, strconv.FormatInt(nextPos, 10))
 577
 578         acl, err := cs.creBucket.GetObjectACL(objectName, RequestPayer(Requester))
 579         c.Assert(err, IsNil)
 580         testLogger.Println("GetObjectACL:", acl)
 581         c.Assert(acl.ACL, Equals, string(ACLPublicReadWrite))
 582
 583         // Second append
 584         options = []Option{
 585                 ObjectACL(ACLPublicRead),
 586                 Meta("my", "myproptwo"),
 587                 Meta("mine", "mypropmine"),
 588                 RequestPayer(Requester),
 589         }
 590         fd, err = os.Open(localFile + "2")
 591         c.Assert(err, IsNil)
 592         defer fd.Close()
 593         nextPos, err = cs.creBucket.AppendObject(objectName, fd, nextPos, options...)
 594         c.Assert(err, IsNil)
 595
 596         body, err = cs.creBucket.GetObject(objectName, RequestPayer(Requester))
 597         c.Assert(err, IsNil)
 598         str, err = readBody(body)
 599         c.Assert(err, IsNil)
 600         c.Assert(str, Equals, objectValue)
 601
 602         meta, err = cs.creBucket.GetObjectDetailedMeta(objectName, RequestPayer(Requester))
 603         c.Assert(err, IsNil)
 604         testLogger.Println("GetObjectDetailedMeta xxx:", meta)
 605         c.Assert(meta.Get("X-Oss-Object-Type"), Equals, "Appendable")
 606         c.Assert(meta.Get("X-Oss-Meta-My"), Equals, "myprop")
 607         c.Assert(meta.Get("x-Oss-Meta-Mine"), Equals, "")
 608         c.Assert(meta.Get("X-Oss-Next-Append-Position"), Equals, strconv.FormatInt(nextPos, 10))
 609
 610         acl, err = cs.creBucket.GetObjectACL(objectName, RequestPayer(Requester))
 611         c.Assert(err, IsNil)
 612         c.Assert(acl.ACL, Equals, string(ACLPublicRead))
 613
 614         err = cs.creBucket.DeleteObject(objectName, RequestPayer(Requester))
 615         c.Assert(err, IsNil)
 616 }