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

   1 // multipart test
   2
   3 package oss
   4
   5 import (
   6         "math/rand"
   7         "net/http"
   8         "os"
   9         "strconv"
  10
  11         . "gopkg.in/check.v1"
  12 )
  13
  14 type OssBucketMultipartSuite struct {
  15         client *Client
  16         bucket *Bucket
  17 }
  18
  19 var _ = Suite(&OssBucketMultipartSuite{})
  20
  21 // SetUpSuite runs once when the suite starts running
  22 func (s *OssBucketMultipartSuite) SetUpSuite(c *C) {
  23         client, err := New(endpoint, accessID, accessKey)
  24         c.Assert(err, IsNil)
  25         s.client = client
  26
  27         s.client.CreateBucket(bucketName)
  28
  29         bucket, err := s.client.Bucket(bucketName)
  30         c.Assert(err, IsNil)
  31         s.bucket = bucket
  32
  33         // Delete part
  34         keyMarker := KeyMarker("")
  35         uploadIDMarker := UploadIDMarker("")
  36         for {
  37                 lmur, err := s.bucket.ListMultipartUploads(keyMarker, uploadIDMarker)
  38                 c.Assert(err, IsNil)
  39                 for _, upload := range lmur.Uploads {
  40                         var imur = InitiateMultipartUploadResult{Bucket: s.bucket.BucketName,
  41                                 Key: upload.Key, UploadID: upload.UploadID}
  42                         err = s.bucket.AbortMultipartUpload(imur)
  43                         c.Assert(err, IsNil)
  44                 }
  45                 keyMarker = KeyMarker(lmur.NextKeyMarker)
  46                 uploadIDMarker = UploadIDMarker(lmur.NextUploadIDMarker)
  47                 if !lmur.IsTruncated {
  48                         break
  49                 }
  50         }
  51
  52         // Delete objects
  53         marker := Marker("")
  54         for {
  55                 lor, err := s.bucket.ListObjects(marker)
  56                 c.Assert(err, IsNil)
  57                 for _, object := range lor.Objects {
  58                         err = s.bucket.DeleteObject(object.Key)
  59                         c.Assert(err, IsNil)
  60                 }
  61                 marker = Marker(lor.NextMarker)
  62                 if !lor.IsTruncated {
  63                         break
  64                 }
  65         }
  66
  67         testLogger.Println("test multipart started")
  68 }
  69
  70 // TearDownSuite runs before each test or benchmark starts running
  71 func (s *OssBucketMultipartSuite) TearDownSuite(c *C) {
  72         // Delete part
  73         keyMarker := KeyMarker("")
  74         uploadIDMarker := UploadIDMarker("")
  75         for {
  76                 lmur, err := s.bucket.ListMultipartUploads(keyMarker, uploadIDMarker)
  77                 c.Assert(err, IsNil)
  78                 for _, upload := range lmur.Uploads {
  79                         var imur = InitiateMultipartUploadResult{Bucket: s.bucket.BucketName,
  80                                 Key: upload.Key, UploadID: upload.UploadID}
  81                         err = s.bucket.AbortMultipartUpload(imur)
  82                         c.Assert(err, IsNil)
  83                 }
  84                 keyMarker = KeyMarker(lmur.NextKeyMarker)
  85                 uploadIDMarker = UploadIDMarker(lmur.NextUploadIDMarker)
  86                 if !lmur.IsTruncated {
  87                         break
  88                 }
  89         }
  90
  91         // Delete objects
  92         marker := Marker("")
  93         for {
  94                 lor, err := s.bucket.ListObjects(marker)
  95                 c.Assert(err, IsNil)
  96                 for _, object := range lor.Objects {
  97                         err = s.bucket.DeleteObject(object.Key)
  98                         c.Assert(err, IsNil)
  99                 }
 100                 marker = Marker(lor.NextMarker)
 101                 if !lor.IsTruncated {
 102                         break
 103                 }
 104         }
 105
 106         // Delete bucket
 107         err := s.client.DeleteBucket(s.bucket.BucketName)
 108         c.Assert(err, IsNil)
 109
 110         testLogger.Println("test multipart completed")
 111 }
 112
 113 // SetUpTest runs after each test or benchmark runs
 114 func (s *OssBucketMultipartSuite) SetUpTest(c *C) {
 115         err := removeTempFiles("../oss", ".jpg")
 116         c.Assert(err, IsNil)
 117 }
 118
 119 // TearDownTest runs once after all tests or benchmarks have finished running
 120 func (s *OssBucketMultipartSuite) TearDownTest(c *C) {
 121         err := removeTempFiles("../oss", ".jpg")
 122         c.Assert(err, IsNil)
 123
 124         err = removeTempFiles("../oss", ".temp")
 125         c.Assert(err, IsNil)
 126
 127         err = removeTempFiles("../oss", ".txt1")
 128         c.Assert(err, IsNil)
 129
 130         err = removeTempFiles("../oss", ".txt2")
 131         c.Assert(err, IsNil)
 132 }
 133
 134 // TestMultipartUpload
 135 func (s *OssBucketMultipartSuite) TestMultipartUpload(c *C) {
 136         objectName := objectNamePrefix + RandStr(8)
 137         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 138
 139         chunks, err := SplitFileByPartNum(fileName, 3)
 140         c.Assert(err, IsNil)
 141         testLogger.Println("chunks:", chunks)
 142
 143         options := []Option{
 144                 Expires(futureDate), Meta("my", "myprop"),
 145         }
 146
 147         fd, err := os.Open(fileName)
 148         c.Assert(err, IsNil)
 149         defer fd.Close()
 150
 151         imur, err := s.bucket.InitiateMultipartUpload(objectName, options...)
 152         c.Assert(err, IsNil)
 153         var parts []UploadPart
 154         for _, chunk := range chunks {
 155                 fd.Seek(chunk.Offset, os.SEEK_SET)
 156                 part, err := s.bucket.UploadPart(imur, fd, chunk.Size, chunk.Number)
 157                 c.Assert(err, IsNil)
 158                 parts = append(parts, part)
 159         }
 160
 161         cmur, err := s.bucket.CompleteMultipartUpload(imur, parts)
 162         c.Assert(err, IsNil)
 163         testLogger.Println("cmur:", cmur)
 164
 165         meta, err := s.bucket.GetObjectDetailedMeta(objectName)
 166         c.Assert(err, IsNil)
 167         testLogger.Println("GetObjectDetailedMeta:", meta)
 168         c.Assert(meta.Get("X-Oss-Meta-My"), Equals, "myprop")
 169         c.Assert(meta.Get("Expires"), Equals, futureDate.Format(http.TimeFormat))
 170         c.Assert(meta.Get("X-Oss-Object-Type"), Equals, "Multipart")
 171
 172         err = s.bucket.GetObjectToFile(objectName, "newpic1.jpg")
 173         c.Assert(err, IsNil)
 174
 175         err = s.bucket.DeleteObject(objectName)
 176         c.Assert(err, IsNil)
 177 }
 178
 179 // TestMultipartUploadFromFile
 180 func (s *OssBucketMultipartSuite) TestMultipartUploadFromFile(c *C) {
 181         objectName := objectNamePrefix + RandStr(8)
 182         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 183
 184         chunks, err := SplitFileByPartNum(fileName, 3)
 185         c.Assert(err, IsNil)
 186         testLogger.Println("chunks:", chunks)
 187
 188         options := []Option{
 189                 Expires(futureDate), Meta("my", "myprop"),
 190         }
 191         imur, err := s.bucket.InitiateMultipartUpload(objectName, options...)
 192         c.Assert(err, IsNil)
 193         var parts []UploadPart
 194         for _, chunk := range chunks {
 195                 part, err := s.bucket.UploadPartFromFile(imur, fileName, chunk.Offset, chunk.Size, chunk.Number)
 196                 c.Assert(err, IsNil)
 197                 parts = append(parts, part)
 198         }
 199
 200         cmur, err := s.bucket.CompleteMultipartUpload(imur, parts)
 201         c.Assert(err, IsNil)
 202         testLogger.Println("cmur:", cmur)
 203
 204         meta, err := s.bucket.GetObjectDetailedMeta(objectName)
 205         c.Assert(err, IsNil)
 206         testLogger.Println("GetObjectDetailedMeta:", meta)
 207         c.Assert(meta.Get("X-Oss-Meta-My"), Equals, "myprop")
 208         c.Assert(meta.Get("Expires"), Equals, futureDate.Format(http.TimeFormat))
 209         c.Assert(meta.Get("X-Oss-Object-Type"), Equals, "Multipart")
 210
 211         err = s.bucket.GetObjectToFile(objectName, "newpic1.jpg")
 212         c.Assert(err, IsNil)
 213
 214         err = s.bucket.DeleteObject(objectName)
 215         c.Assert(err, IsNil)
 216 }
 217
 218 // TestUploadPartCopy
 219 func (s *OssBucketMultipartSuite) TestUploadPartCopy(c *C) {
 220         objectSrc := objectNamePrefix + RandStr(8) + "-src"
 221         objectDest := objectNamePrefix + RandStr(8) + "-dest"
 222         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 223
 224         chunks, err := SplitFileByPartNum(fileName, 3)
 225         c.Assert(err, IsNil)
 226         testLogger.Println("chunks:", chunks)
 227
 228         err = s.bucket.PutObjectFromFile(objectSrc, fileName)
 229         c.Assert(err, IsNil)
 230
 231         options := []Option{
 232                 Expires(futureDate), Meta("my", "myprop"),
 233         }
 234         imur, err := s.bucket.InitiateMultipartUpload(objectDest, options...)
 235         c.Assert(err, IsNil)
 236         var parts []UploadPart
 237         for _, chunk := range chunks {
 238                 part, err := s.bucket.UploadPartCopy(imur, bucketName, objectSrc, chunk.Offset, chunk.Size, (int)(chunk.Number))
 239                 c.Assert(err, IsNil)
 240                 parts = append(parts, part)
 241         }
 242
 243         cmur, err := s.bucket.CompleteMultipartUpload(imur, parts)
 244         c.Assert(err, IsNil)
 245         testLogger.Println("cmur:", cmur)
 246
 247         meta, err := s.bucket.GetObjectDetailedMeta(objectDest)
 248         c.Assert(err, IsNil)
 249         testLogger.Println("GetObjectDetailedMeta:", meta)
 250         c.Assert(meta.Get("X-Oss-Meta-My"), Equals, "myprop")
 251         c.Assert(meta.Get("Expires"), Equals, futureDate.Format(http.TimeFormat))
 252         c.Assert(meta.Get("X-Oss-Object-Type"), Equals, "Multipart")
 253
 254         err = s.bucket.GetObjectToFile(objectDest, "newpic2.jpg")
 255         c.Assert(err, IsNil)
 256
 257         err = s.bucket.DeleteObject(objectSrc)
 258         c.Assert(err, IsNil)
 259         err = s.bucket.DeleteObject(objectDest)
 260         c.Assert(err, IsNil)
 261 }
 262
 263 func (s *OssBucketMultipartSuite) TestListUploadedParts(c *C) {
 264         objectName := objectNamePrefix + RandStr(8)
 265         objectSrc := objectName + "-src"
 266         objectDest := objectName + "-dest"
 267         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 268
 269         chunks, err := SplitFileByPartSize(fileName, 100*1024)
 270         c.Assert(err, IsNil)
 271         testLogger.Println("chunks:", chunks)
 272
 273         err = s.bucket.PutObjectFromFile(objectSrc, fileName)
 274         c.Assert(err, IsNil)
 275
 276         // Upload
 277         imurUpload, err := s.bucket.InitiateMultipartUpload(objectName)
 278         var partsUpload []UploadPart
 279         for _, chunk := range chunks {
 280                 part, err := s.bucket.UploadPartFromFile(imurUpload, fileName, chunk.Offset, chunk.Size, (int)(chunk.Number))
 281                 c.Assert(err, IsNil)
 282                 partsUpload = append(partsUpload, part)
 283         }
 284
 285         // Copy
 286         imurCopy, err := s.bucket.InitiateMultipartUpload(objectDest)
 287         var partsCopy []UploadPart
 288         for _, chunk := range chunks {
 289                 part, err := s.bucket.UploadPartCopy(imurCopy, bucketName, objectSrc, chunk.Offset, chunk.Size, (int)(chunk.Number))
 290                 c.Assert(err, IsNil)
 291                 partsCopy = append(partsCopy, part)
 292         }
 293
 294         // List
 295         lupr, err := s.bucket.ListUploadedParts(imurUpload)
 296         c.Assert(err, IsNil)
 297         testLogger.Println("lupr:", lupr)
 298         c.Assert(len(lupr.UploadedParts), Equals, len(chunks))
 299
 300         lupr, err = s.bucket.ListUploadedParts(imurCopy)
 301         c.Assert(err, IsNil)
 302         testLogger.Println("lupr:", lupr)
 303         c.Assert(len(lupr.UploadedParts), Equals, len(chunks))
 304
 305         lmur, err := s.bucket.ListMultipartUploads()
 306         c.Assert(err, IsNil)
 307         testLogger.Println("lmur:", lmur)
 308
 309         // Complete
 310         _, err = s.bucket.CompleteMultipartUpload(imurUpload, partsUpload)
 311         c.Assert(err, IsNil)
 312         _, err = s.bucket.CompleteMultipartUpload(imurCopy, partsCopy)
 313         c.Assert(err, IsNil)
 314
 315         // Download
 316         err = s.bucket.GetObjectToFile(objectDest, "newpic3.jpg")
 317         c.Assert(err, IsNil)
 318         err = s.bucket.GetObjectToFile(objectName, "newpic4.jpg")
 319         c.Assert(err, IsNil)
 320
 321         err = s.bucket.DeleteObject(objectName)
 322         c.Assert(err, IsNil)
 323         err = s.bucket.DeleteObject(objectDest)
 324         c.Assert(err, IsNil)
 325         err = s.bucket.DeleteObject(objectSrc)
 326         c.Assert(err, IsNil)
 327 }
 328
 329 func (s *OssBucketMultipartSuite) TestAbortMultipartUpload(c *C) {
 330         objectName := objectNamePrefix + RandStr(8)
 331         objectSrc := objectName + "-src"
 332         objectDest := objectName + "-dest"
 333         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 334
 335         chunks, err := SplitFileByPartSize(fileName, 100*1024)
 336         c.Assert(err, IsNil)
 337         testLogger.Println("chunks:", chunks)
 338
 339         err = s.bucket.PutObjectFromFile(objectSrc, fileName)
 340         c.Assert(err, IsNil)
 341
 342         // Upload
 343         imurUpload, err := s.bucket.InitiateMultipartUpload(objectName)
 344         var partsUpload []UploadPart
 345         for _, chunk := range chunks {
 346                 part, err := s.bucket.UploadPartFromFile(imurUpload, fileName, chunk.Offset, chunk.Size, (int)(chunk.Number))
 347                 c.Assert(err, IsNil)
 348                 partsUpload = append(partsUpload, part)
 349         }
 350
 351         // Copy
 352         imurCopy, err := s.bucket.InitiateMultipartUpload(objectDest)
 353         var partsCopy []UploadPart
 354         for _, chunk := range chunks {
 355                 part, err := s.bucket.UploadPartCopy(imurCopy, bucketName, objectSrc, chunk.Offset, chunk.Size, (int)(chunk.Number))
 356                 c.Assert(err, IsNil)
 357                 partsCopy = append(partsCopy, part)
 358         }
 359
 360         // List
 361         lupr, err := s.bucket.ListUploadedParts(imurUpload)
 362         c.Assert(err, IsNil)
 363         testLogger.Println("lupr:", lupr)
 364         c.Assert(len(lupr.UploadedParts), Equals, len(chunks))
 365
 366         lupr, err = s.bucket.ListUploadedParts(imurCopy)
 367         c.Assert(err, IsNil)
 368         testLogger.Println("lupr:", lupr)
 369         c.Assert(len(lupr.UploadedParts), Equals, len(chunks))
 370
 371         lmur, err := s.bucket.ListMultipartUploads()
 372         c.Assert(err, IsNil)
 373         testLogger.Println("lmur:", lmur)
 374         c.Assert(len(lmur.Uploads), Equals, 2)
 375
 376         // Abort
 377         err = s.bucket.AbortMultipartUpload(imurUpload)
 378         c.Assert(err, IsNil)
 379         err = s.bucket.AbortMultipartUpload(imurCopy)
 380         c.Assert(err, IsNil)
 381
 382         lmur, err = s.bucket.ListMultipartUploads()
 383         c.Assert(err, IsNil)
 384         testLogger.Println("lmur:", lmur)
 385         c.Assert(len(lmur.Uploads), Equals, 0)
 386
 387         // Download
 388         err = s.bucket.GetObjectToFile(objectDest, "newpic3.jpg")
 389         c.Assert(err, NotNil)
 390         err = s.bucket.GetObjectToFile(objectName, "newpic4.jpg")
 391         c.Assert(err, NotNil)
 392 }
 393
 394 // TestUploadPartCopyWithConstraints
 395 func (s *OssBucketMultipartSuite) TestUploadPartCopyWithConstraints(c *C) {
 396         objectSrc := objectNamePrefix + RandStr(8) + "-src"
 397         objectDest := objectNamePrefix + RandStr(8) + "-dest"
 398         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 399
 400         chunks, err := SplitFileByPartNum(fileName, 3)
 401         c.Assert(err, IsNil)
 402         testLogger.Println("chunks:", chunks)
 403
 404         err = s.bucket.PutObjectFromFile(objectSrc, fileName)
 405         c.Assert(err, IsNil)
 406
 407         imur, err := s.bucket.InitiateMultipartUpload(objectDest)
 408         var parts []UploadPart
 409         for _, chunk := range chunks {
 410                 _, err = s.bucket.UploadPartCopy(imur, bucketName, objectSrc, chunk.Offset, chunk.Size, (int)(chunk.Number),
 411                         CopySourceIfModifiedSince(futureDate))
 412                 c.Assert(err, NotNil)
 413         }
 414
 415         for _, chunk := range chunks {
 416                 _, err = s.bucket.UploadPartCopy(imur, bucketName, objectSrc, chunk.Offset, chunk.Size, (int)(chunk.Number),
 417                         CopySourceIfUnmodifiedSince(futureDate))
 418                 c.Assert(err, IsNil)
 419         }
 420
 421         meta, err := s.bucket.GetObjectDetailedMeta(objectSrc)
 422         c.Assert(err, IsNil)
 423         testLogger.Println("GetObjectDetailedMeta:", meta)
 424
 425         for _, chunk := range chunks {
 426                 _, err = s.bucket.UploadPartCopy(imur, bucketName, objectSrc, chunk.Offset, chunk.Size, (int)(chunk.Number),
 427                         CopySourceIfNoneMatch(meta.Get("Etag")))
 428                 c.Assert(err, NotNil)
 429         }
 430
 431         for _, chunk := range chunks {
 432                 part, err := s.bucket.UploadPartCopy(imur, bucketName, objectSrc, chunk.Offset, chunk.Size, (int)(chunk.Number),
 433                         CopySourceIfMatch(meta.Get("Etag")))
 434                 c.Assert(err, IsNil)
 435                 parts = append(parts, part)
 436         }
 437
 438         cmur, err := s.bucket.CompleteMultipartUpload(imur, parts)
 439         c.Assert(err, IsNil)
 440         testLogger.Println("cmur:", cmur)
 441
 442         err = s.bucket.GetObjectToFile(objectDest, "newpic5.jpg")
 443         c.Assert(err, IsNil)
 444
 445         err = s.bucket.DeleteObject(objectSrc)
 446         c.Assert(err, IsNil)
 447         err = s.bucket.DeleteObject(objectDest)
 448         c.Assert(err, IsNil)
 449 }
 450
 451 // TestMultipartUploadFromFileOutofOrder
 452 func (s *OssBucketMultipartSuite) TestMultipartUploadFromFileOutofOrder(c *C) {
 453         objectName := objectNamePrefix + RandStr(8)
 454         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 455
 456         chunks, err := SplitFileByPartSize(fileName, 1024*100)
 457         shuffleArray(chunks)
 458         c.Assert(err, IsNil)
 459         testLogger.Println("chunks:", chunks)
 460
 461         imur, err := s.bucket.InitiateMultipartUpload(objectName)
 462         var parts []UploadPart
 463         for _, chunk := range chunks {
 464                 _, err := s.bucket.UploadPartFromFile(imur, fileName, chunk.Offset, chunk.Size, (int)(chunk.Number))
 465                 c.Assert(err, IsNil)
 466         }
 467         // Double upload
 468         for _, chunk := range chunks {
 469                 part, err := s.bucket.UploadPartFromFile(imur, fileName, chunk.Offset, chunk.Size, (int)(chunk.Number))
 470                 c.Assert(err, IsNil)
 471                 parts = append(parts, part)
 472         }
 473
 474         cmur, err := s.bucket.CompleteMultipartUpload(imur, parts)
 475         c.Assert(err, IsNil)
 476         testLogger.Println("cmur:", cmur)
 477
 478         err = s.bucket.GetObjectToFile(objectName, "newpic6.jpg")
 479         c.Assert(err, IsNil)
 480
 481         err = s.bucket.DeleteObject(objectName)
 482         c.Assert(err, IsNil)
 483 }
 484
 485 // TestUploadPartCopyOutofOrder
 486 func (s *OssBucketMultipartSuite) TestUploadPartCopyOutofOrder(c *C) {
 487         objectSrc := objectNamePrefix + RandStr(8) + "-src"
 488         objectDest := objectNamePrefix + RandStr(8) + "-dest"
 489         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 490
 491         chunks, err := SplitFileByPartSize(fileName, 1024*100)
 492         shuffleArray(chunks)
 493         c.Assert(err, IsNil)
 494         testLogger.Println("chunks:", chunks)
 495
 496         err = s.bucket.PutObjectFromFile(objectSrc, fileName)
 497         c.Assert(err, IsNil)
 498
 499         imur, err := s.bucket.InitiateMultipartUpload(objectDest)
 500         var parts []UploadPart
 501         for _, chunk := range chunks {
 502                 _, err := s.bucket.UploadPartCopy(imur, bucketName, objectSrc, chunk.Offset, chunk.Size, (int)(chunk.Number))
 503                 c.Assert(err, IsNil)
 504         }
 505         // Double copy
 506         for _, chunk := range chunks {
 507                 part, err := s.bucket.UploadPartCopy(imur, bucketName, objectSrc, chunk.Offset, chunk.Size, (int)(chunk.Number))
 508                 c.Assert(err, IsNil)
 509                 parts = append(parts, part)
 510         }
 511
 512         cmur, err := s.bucket.CompleteMultipartUpload(imur, parts)
 513         c.Assert(err, IsNil)
 514         testLogger.Println("cmur:", cmur)
 515
 516         err = s.bucket.GetObjectToFile(objectDest, "newpic7.jpg")
 517         c.Assert(err, IsNil)
 518
 519         err = s.bucket.DeleteObject(objectSrc)
 520         c.Assert(err, IsNil)
 521         err = s.bucket.DeleteObject(objectDest)
 522         c.Assert(err, IsNil)
 523 }
 524
 525 // TestMultipartUploadFromFileType
 526 func (s *OssBucketMultipartSuite) TestMultipartUploadFromFileType(c *C) {
 527         objectName := objectNamePrefix + RandStr(8) + ".jpg"
 528         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 529
 530         chunks, err := SplitFileByPartNum(fileName, 4)
 531         c.Assert(err, IsNil)
 532         testLogger.Println("chunks:", chunks)
 533
 534         imur, err := s.bucket.InitiateMultipartUpload(objectName)
 535         var parts []UploadPart
 536         for _, chunk := range chunks {
 537                 part, err := s.bucket.UploadPartFromFile(imur, fileName, chunk.Offset, chunk.Size, chunk.Number)
 538                 c.Assert(err, IsNil)
 539                 parts = append(parts, part)
 540         }
 541
 542         testLogger.Println("parts:", parts)
 543         cmur, err := s.bucket.CompleteMultipartUpload(imur, parts)
 544         c.Assert(err, IsNil)
 545         testLogger.Println("cmur:", cmur)
 546
 547         err = s.bucket.GetObjectToFile(objectName, "newpic8.jpg")
 548         c.Assert(err, IsNil)
 549
 550         meta, err := s.bucket.GetObjectDetailedMeta(objectName)
 551         c.Assert(err, IsNil)
 552         c.Assert(meta.Get("Content-Type"), Equals, "image/jpeg")
 553
 554         err = s.bucket.DeleteObject(objectName)
 555         c.Assert(err, IsNil)
 556 }
 557
 558 func (s *OssBucketMultipartSuite) TestListMultipartUploads(c *C) {
 559         objectName := objectNamePrefix + RandStr(8)
 560
 561         imurs := []InitiateMultipartUploadResult{}
 562         for i := 0; i < 20; i++ {
 563                 imur, err := s.bucket.InitiateMultipartUpload(objectName + strconv.Itoa(i))
 564                 c.Assert(err, IsNil)
 565                 imurs = append(imurs, imur)
 566         }
 567
 568         lmpu, err := s.bucket.ListMultipartUploads()
 569         c.Assert(err, IsNil)
 570         c.Assert(len(lmpu.Uploads), Equals, 20)
 571
 572         lmpu, err = s.bucket.ListMultipartUploads(MaxUploads(3))
 573         c.Assert(err, IsNil)
 574         c.Assert(len(lmpu.Uploads), Equals, 3)
 575
 576         lmpu, err = s.bucket.ListMultipartUploads(Prefix(objectName))
 577         c.Assert(err, IsNil)
 578         c.Assert(len(lmpu.Uploads), Equals, 20)
 579
 580         lmpu, err = s.bucket.ListMultipartUploads(Prefix(objectName + "1"))
 581         c.Assert(err, IsNil)
 582         c.Assert(len(lmpu.Uploads), Equals, 11)
 583
 584         lmpu, err = s.bucket.ListMultipartUploads(Prefix(objectName + "22"))
 585         c.Assert(err, IsNil)
 586         c.Assert(len(lmpu.Uploads), Equals, 0)
 587
 588         lmpu, err = s.bucket.ListMultipartUploads(KeyMarker(objectName + "10"))
 589         c.Assert(err, IsNil)
 590         c.Assert(len(lmpu.Uploads), Equals, 17)
 591
 592         lmpu, err = s.bucket.ListMultipartUploads(KeyMarker(objectName+"10"), MaxUploads(3))
 593         c.Assert(err, IsNil)
 594         c.Assert(len(lmpu.Uploads), Equals, 3)
 595
 596         lmpu, err = s.bucket.ListMultipartUploads(Prefix(objectName), Delimiter("4"))
 597         c.Assert(err, IsNil)
 598         c.Assert(len(lmpu.Uploads), Equals, 18)
 599         c.Assert(len(lmpu.CommonPrefixes), Equals, 2)
 600
 601         upLoadIDStr := RandStr(3)
 602         lmpu, err = s.bucket.ListMultipartUploads(KeyMarker(objectName+"12"), UploadIDMarker(upLoadIDStr))
 603         c.Assert(err, IsNil)
 604         checkNum := 15
 605         for _, im := range imurs {
 606                 if im.Key == objectName+"12" && im.UploadID > upLoadIDStr {
 607                         checkNum = 16
 608                         break
 609                 }
 610         }
 611         c.Assert(len(lmpu.Uploads), Equals, checkNum)
 612         //testLogger.Println("UploadIDMarker", lmpu.Uploads)
 613
 614         for _, imur := range imurs {
 615                 err = s.bucket.AbortMultipartUpload(imur)
 616                 c.Assert(err, IsNil)
 617         }
 618 }
 619
 620 func (s *OssBucketMultipartSuite) TestListMultipartUploadsEncodingKey(c *C) {
 621         prefix := objectNamePrefix + "让你任性让你狂" + RandStr(8)
 622
 623         imurs := []InitiateMultipartUploadResult{}
 624         for i := 0; i < 3; i++ {
 625                 imur, err := s.bucket.InitiateMultipartUpload(prefix + strconv.Itoa(i))
 626                 c.Assert(err, IsNil)
 627                 imurs = append(imurs, imur)
 628         }
 629
 630         lmpu, err := s.bucket.ListMultipartUploads()
 631         c.Assert(err, IsNil)
 632         c.Assert(len(lmpu.Uploads), Equals, 3)
 633
 634         lmpu, err = s.bucket.ListMultipartUploads(Prefix(prefix + "1"))
 635         c.Assert(err, IsNil)
 636         c.Assert(len(lmpu.Uploads), Equals, 1)
 637
 638         lmpu, err = s.bucket.ListMultipartUploads(KeyMarker(prefix + "1"))
 639         c.Assert(err, IsNil)
 640         c.Assert(len(lmpu.Uploads), Equals, 1)
 641
 642         lmpu, err = s.bucket.ListMultipartUploads(EncodingType("url"))
 643         c.Assert(err, IsNil)
 644         for i, upload := range lmpu.Uploads {
 645                 c.Assert(upload.Key, Equals, prefix+strconv.Itoa(i))
 646         }
 647
 648         for _, imur := range imurs {
 649                 err = s.bucket.AbortMultipartUpload(imur)
 650                 c.Assert(err, IsNil)
 651         }
 652 }
 653
 654 func (s *OssBucketMultipartSuite) TestMultipartNegative(c *C) {
 655         objectName := objectNamePrefix + RandStr(8)
 656
 657         // Key tool long
 658         data := make([]byte, 100*1024)
 659         imur, err := s.bucket.InitiateMultipartUpload(string(data))
 660         c.Assert(err, NotNil)
 661
 662         // Invalid imur
 663         fileName := "../sample/BingWallpaper-2015-11-07.jpg"
 664         fd, err := os.Open(fileName)
 665         c.Assert(err, IsNil)
 666         defer fd.Close()
 667
 668         _, err = s.bucket.UploadPart(imur, fd, 1024, 1)
 669         c.Assert(err, NotNil)
 670
 671         _, err = s.bucket.UploadPartFromFile(imur, fileName, 0, 1024, 1)
 672         c.Assert(err, NotNil)
 673
 674         _, err = s.bucket.UploadPartCopy(imur, bucketName, fileName, 0, 1024, 1)
 675         c.Assert(err, NotNil)
 676
 677         err = s.bucket.AbortMultipartUpload(imur)
 678         c.Assert(err, NotNil)
 679
 680         _, err = s.bucket.ListUploadedParts(imur)
 681         c.Assert(err, NotNil)
 682
 683         // Invalid exist
 684         imur, err = s.bucket.InitiateMultipartUpload(objectName)
 685         c.Assert(err, IsNil)
 686
 687         _, err = s.bucket.UploadPart(imur, fd, 1024, 1)
 688         c.Assert(err, IsNil)
 689
 690         _, err = s.bucket.UploadPart(imur, fd, 102400, 10001)
 691         c.Assert(err, NotNil)
 692
 693         //    _, err = s.bucket.UploadPartFromFile(imur, fileName, 0, 1024, 1)
 694         //    c.Assert(err, IsNil)
 695
 696         _, err = s.bucket.UploadPartFromFile(imur, fileName, 0, 102400, 10001)
 697         c.Assert(err, NotNil)
 698
 699         _, err = s.bucket.UploadPartCopy(imur, bucketName, fileName, 0, 1024, 1)
 700         c.Assert(err, NotNil)
 701
 702         _, err = s.bucket.UploadPartCopy(imur, bucketName, fileName, 0, 1024, 1000)
 703         c.Assert(err, NotNil)
 704
 705         err = s.bucket.AbortMultipartUpload(imur)
 706         c.Assert(err, IsNil)
 707
 708         // Invalid option
 709         _, err = s.bucket.InitiateMultipartUpload(objectName, IfModifiedSince(futureDate))
 710         c.Assert(err, IsNil)
 711 }
 712
 713 func (s *OssBucketMultipartSuite) TestMultipartUploadFromFileBigFile(c *C) {
 714         objectName := objectNamePrefix + RandStr(8)
 715         bigFile := "D:\\tmp\\bigfile.zip"
 716         newFile := "D:\\tmp\\newbigfile.zip"
 717
 718         exist, err := isFileExist(bigFile)
 719         c.Assert(err, IsNil)
 720         if !exist {
 721                 return
 722         }
 723
 724         chunks, err := SplitFileByPartNum(bigFile, 64)
 725         c.Assert(err, IsNil)
 726         testLogger.Println("chunks:", chunks)
 727
 728         imur, err := s.bucket.InitiateMultipartUpload(objectName)
 729         var parts []UploadPart
 730         start := GetNowSec()
 731         for _, chunk := range chunks {
 732                 part, err := s.bucket.UploadPartFromFile(imur, bigFile, chunk.Offset, chunk.Size, (int)(chunk.Number))
 733                 c.Assert(err, IsNil)
 734                 parts = append(parts, part)
 735         }
 736         end := GetNowSec()
 737         testLogger.Println("Uplaod big file:", bigFile, "use sec:", end-start)
 738
 739         testLogger.Println("parts:", parts)
 740         _, err = s.bucket.CompleteMultipartUpload(imur, parts)
 741         c.Assert(err, IsNil)
 742
 743         start = GetNowSec()
 744         err = s.bucket.GetObjectToFile(objectName, newFile)
 745         c.Assert(err, IsNil)
 746         end = GetNowSec()
 747         testLogger.Println("Download big file:", bigFile, "use sec:", end-start)
 748
 749         start = GetNowSec()
 750         eq, err := compareFiles(bigFile, newFile)
 751         c.Assert(err, IsNil)
 752         c.Assert(eq, Equals, true)
 753         end = GetNowSec()
 754         testLogger.Println("Compare big file:", bigFile, "use sec:", end-start)
 755
 756         err = s.bucket.DeleteObject(objectName)
 757         c.Assert(err, IsNil)
 758 }
 759
 760 // TestUploadFile
 761 func (s *OssBucketMultipartSuite) TestUploadFile(c *C) {
 762         objectName := objectNamePrefix + RandStr(8)
 763         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 764         newFile := RandStr(8) + ".jpg"
 765
 766         // Upload with 100K part size
 767         err := s.bucket.UploadFile(objectName, fileName, 100*1024)
 768         c.Assert(err, IsNil)
 769
 770         os.Remove(newFile)
 771         err = s.bucket.GetObjectToFile(objectName, newFile)
 772         c.Assert(err, IsNil)
 773
 774         eq, err := compareFiles(fileName, newFile)
 775         c.Assert(err, IsNil)
 776         c.Assert(eq, Equals, true)
 777
 778         err = s.bucket.DeleteObject(objectName)
 779         c.Assert(err, IsNil)
 780
 781         // Upload with part size equals to 1/4 of the file size
 782         err = s.bucket.UploadFile(objectName, fileName, 482048/4)
 783         c.Assert(err, IsNil)
 784
 785         os.Remove(newFile)
 786         err = s.bucket.GetObjectToFile(objectName, newFile)
 787         c.Assert(err, IsNil)
 788
 789         eq, err = compareFiles(fileName, newFile)
 790         c.Assert(err, IsNil)
 791         c.Assert(eq, Equals, true)
 792
 793         err = s.bucket.DeleteObject(objectName)
 794         c.Assert(err, IsNil)
 795
 796         // Upload with part size equals to the file size
 797         err = s.bucket.UploadFile(objectName, fileName, 482048)
 798         c.Assert(err, IsNil)
 799
 800         os.Remove(newFile)
 801         err = s.bucket.GetObjectToFile(objectName, newFile)
 802         c.Assert(err, IsNil)
 803
 804         eq, err = compareFiles(fileName, newFile)
 805         c.Assert(err, IsNil)
 806         c.Assert(eq, Equals, true)
 807
 808         err = s.bucket.DeleteObject(objectName)
 809         c.Assert(err, IsNil)
 810
 811         // Upload with part size is bigger than the file size
 812         err = s.bucket.UploadFile(objectName, fileName, 482049)
 813         c.Assert(err, IsNil)
 814
 815         os.Remove(newFile)
 816         err = s.bucket.GetObjectToFile(objectName, newFile)
 817         c.Assert(err, IsNil)
 818
 819         eq, err = compareFiles(fileName, newFile)
 820         c.Assert(err, IsNil)
 821         c.Assert(eq, Equals, true)
 822
 823         err = s.bucket.DeleteObject(objectName)
 824         c.Assert(err, IsNil)
 825
 826         // Option
 827         options := []Option{
 828                 Expires(futureDate),
 829                 ObjectACL(ACLPublicRead),
 830                 Meta("myprop", "mypropval")}
 831         err = s.bucket.UploadFile(objectName, fileName, 482049, options...)
 832         c.Assert(err, IsNil)
 833
 834         // Check
 835         os.Remove(newFile)
 836         err = s.bucket.GetObjectToFile(objectName, newFile)
 837         c.Assert(err, IsNil)
 838
 839         eq, err = compareFiles(fileName, newFile)
 840         c.Assert(err, IsNil)
 841         c.Assert(eq, Equals, true)
 842
 843         acl, err := s.bucket.GetObjectACL(objectName)
 844         c.Assert(err, IsNil)
 845         testLogger.Println("GetObjectAcl:", acl)
 846         c.Assert(acl.ACL, Equals, "public-read")
 847
 848         meta, err := s.bucket.GetObjectDetailedMeta(objectName)
 849         c.Assert(err, IsNil)
 850         testLogger.Println("GetObjectDetailedMeta:", meta)
 851         c.Assert(meta.Get("X-Oss-Meta-Myprop"), Equals, "mypropval")
 852 }
 853
 854 func (s *OssBucketMultipartSuite) TestUploadFileNegative(c *C) {
 855         objectName := objectNamePrefix + RandStr(8)
 856         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 857
 858         // Smaller than the required minimal part size (100KB)
 859         err := s.bucket.UploadFile(objectName, fileName, 100*1024-1)
 860         c.Assert(err, NotNil)
 861
 862         // Bigger than the max part size (5G)
 863         err = s.bucket.UploadFile(objectName, fileName, 1024*1024*1024*5+1)
 864         c.Assert(err, NotNil)
 865
 866         // File does not exist
 867         err = s.bucket.UploadFile(objectName, "/root1/123abc9874", 1024*1024*1024)
 868         c.Assert(err, NotNil)
 869
 870         // Invalid key , key is empty.
 871         err = s.bucket.UploadFile("", fileName, 100*1024)
 872         c.Assert(err, NotNil)
 873 }
 874
 875 // TestDownloadFile
 876 func (s *OssBucketMultipartSuite) TestDownloadFile(c *C) {
 877         objectName := objectNamePrefix + RandStr(8)
 878         var fileName = "../sample/BingWallpaper-2015-11-07.jpg"
 879         newFile := RandStr(8) + ".jpg"
 880
 881         err := s.bucket.UploadFile(objectName, fileName, 100*1024)
 882         c.Assert(err, IsNil)
 883
 884         // Download file with part size of 100K
 885         err = s.bucket.DownloadFile(objectName, newFile, 100*1024)
 886         c.Assert(err, IsNil)
 887
 888         os.Remove(newFile)
 889         err = s.bucket.GetObjectToFile(objectName, newFile)
 890         c.Assert(err, IsNil)
 891
 892         eq, err := compareFiles(fileName, newFile)
 893         c.Assert(err, IsNil)
 894         c.Assert(eq, Equals, true)
 895
 896         // Download the file with part size equals to 1/4 of the file size
 897         err = s.bucket.DownloadFile(objectName, newFile, 482048/4)
 898         c.Assert(err, IsNil)
 899
 900         os.Remove(newFile)
 901         err = s.bucket.GetObjectToFile(objectName, newFile)
 902         c.Assert(err, IsNil)
 903
 904         eq, err = compareFiles(fileName, newFile)
 905         c.Assert(err, IsNil)
 906         c.Assert(eq, Equals, true)
 907
 908         // Download the file with part size same as the file size
 909         err = s.bucket.DownloadFile(objectName, newFile, 482048)
 910         c.Assert(err, IsNil)
 911
 912         os.Remove(newFile)
 913         err = s.bucket.GetObjectToFile(objectName, newFile)
 914         c.Assert(err, IsNil)
 915
 916         eq, err = compareFiles(fileName, newFile)
 917         c.Assert(err, IsNil)
 918         c.Assert(eq, Equals, true)
 919
 920         // Download the file with part size bigger than the file size
 921         err = s.bucket.DownloadFile(objectName, newFile, 482049)
 922         c.Assert(err, IsNil)
 923
 924         os.Remove(newFile)
 925         err = s.bucket.GetObjectToFile(objectName, newFile)
 926         c.Assert(err, IsNil)
 927
 928         eq, err = compareFiles(fileName, newFile)
 929         c.Assert(err, IsNil)
 930         c.Assert(eq, Equals, true)
 931
 932         // Option
 933         meta, err := s.bucket.GetObjectDetailedMeta(objectName)
 934         c.Assert(err, IsNil)
 935         testLogger.Println("GetObjectDetailedMeta:", meta)
 936
 937         // If-Match
 938         err = s.bucket.DownloadFile(objectName, newFile, 482048/4, IfMatch(meta.Get("Etag")))
 939         c.Assert(err, IsNil)
 940
 941         os.Remove(newFile)
 942         err = s.bucket.GetObjectToFile(objectName, newFile)
 943         c.Assert(err, IsNil)
 944
 945         eq, err = compareFiles(fileName, newFile)
 946         c.Assert(err, IsNil)
 947         c.Assert(eq, Equals, true)
 948
 949         // If-None-Match
 950         err = s.bucket.DownloadFile(objectName, newFile, 482048, IfNoneMatch(meta.Get("Etag")))
 951         c.Assert(err, NotNil)
 952
 953         os.Remove(newFile)
 954         err = s.bucket.DeleteObject(objectName)
 955         c.Assert(err, IsNil)
 956 }
 957
 958 func (s *OssBucketMultipartSuite) TestDownloadFileNegative(c *C) {
 959         objectName := objectNamePrefix + RandStr(8)
 960         newFile := RandStr(8) + ".jpg"
 961
 962         // Smaller than the required minimal part size (100KB)
 963         err := s.bucket.DownloadFile(objectName, newFile, 100*1024-1)
 964         c.Assert(err, NotNil)
 965
 966         // Bigger than the required max part size (5G)
 967         err = s.bucket.DownloadFile(objectName, newFile, 1024*1024*1024+1)
 968         c.Assert(err, NotNil)
 969
 970         // File does not exist
 971         err = s.bucket.DownloadFile(objectName, "/OSS/TEMP/ZIBI/QUQU/BALA", 1024*1024*1024+1)
 972         c.Assert(err, NotNil)
 973
 974         // Key does not exist
 975         err = s.bucket.DownloadFile(objectName, newFile, 100*1024)
 976         c.Assert(err, NotNil)
 977 }
 978
 979 // Private
 980 func shuffleArray(chunks []FileChunk) []FileChunk {
 981         for i := range chunks {
 982                 j := rand.Intn(i + 1)
 983                 chunks[i], chunks[j] = chunks[j], chunks[i]
 984         }
 985         return chunks
 986 }