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

   1 package oss
   2
   3 import (
   4         "fmt"
   5         "io"
   6         "net/http"
   7         "os"
   8         "time"
   9
  10         . "gopkg.in/check.v1"
  11 )
  12
  13 type OssUploadSuite struct {
  14         client *Client
  15         bucket *Bucket
  16 }
  17
  18 var _ = Suite(&OssUploadSuite{})
  19
  20 // SetUpSuite runs once when the suite starts running
  21 func (s *OssUploadSuite) SetUpSuite(c *C) {
  22         client, err := New(endpoint, accessID, accessKey)
  23         c.Assert(err, IsNil)
  24         s.client = client
  25
  26         s.client.CreateBucket(bucketName)
  27
  28         bucket, err := s.client.Bucket(bucketName)
  29         c.Assert(err, IsNil)
  30         s.bucket = bucket
  31
  32         testLogger.Println("test upload started")
  33 }
  34
  35 // TearDownSuite runs before each test or benchmark starts running
  36 func (s *OssUploadSuite) TearDownSuite(c *C) {
  37         // Delete part
  38         keyMarker := KeyMarker("")
  39         uploadIDMarker := UploadIDMarker("")
  40         for {
  41                 lmur, err := s.bucket.ListMultipartUploads(keyMarker, uploadIDMarker)
  42                 c.Assert(err, IsNil)
  43                 for _, upload := range lmur.Uploads {
  44                         var imur = InitiateMultipartUploadResult{Bucket: s.bucket.BucketName,
  45                                 Key: upload.Key, UploadID: upload.UploadID}
  46                         err = s.bucket.AbortMultipartUpload(imur)
  47                         c.Assert(err, IsNil)
  48                 }
  49                 keyMarker = KeyMarker(lmur.NextKeyMarker)
  50                 uploadIDMarker = UploadIDMarker(lmur.NextUploadIDMarker)
  51                 if !lmur.IsTruncated {
  52                         break
  53                 }
  54         }
  55
  56         // Delete objects
  57         marker := Marker("")
  58         for {
  59                 lor, err := s.bucket.ListObjects(marker)
  60                 c.Assert(err, IsNil)
  61                 for _, object := range lor.Objects {
  62                         err = s.bucket.DeleteObject(object.Key)
  63                         c.Assert(err, IsNil)
  64                 }
  65                 marker = Marker(lor.NextMarker)
  66                 if !lor.IsTruncated {
  67                         break
  68                 }
  69         }
  70
  71         // Delete bucket
  72         err := s.client.DeleteBucket(s.bucket.BucketName)
  73         c.Assert(err, IsNil)
  74
  75         testLogger.Println("test upload completed")
  76 }
  77
  78 // SetUpTest runs after each test or benchmark runs
  79 func (s *OssUploadSuite) SetUpTest(c *C) {
  80         err := removeTempFiles("../oss", ".jpg")
  81         c.Assert(err, IsNil)
  82 }
  83
  84 // TearDownTest runs once after all tests or benchmarks have finished running
  85 func (s *OssUploadSuite) TearDownTest(c *C) {
  86         err := removeTempFiles("../oss", ".jpg")
  87         c.Assert(err, IsNil)
  88 }
  89
  90 // TestUploadRoutineWithoutRecovery tests multiroutineed upload without checkpoint
  91 func (s *OssUploadSuite) TestUploadRoutineWithoutRecovery(c *C) {
  92         objectName := objectNamePrefix + RandStr(8)
  93         fileName := "../sample/BingWallpaper-2015-11-07.jpg"
  94         newFile := RandStr(8) + ".jpg"
  95
  96         // Routines is not specified, by default single routine
  97         err := s.bucket.UploadFile(objectName, fileName, 100*1024)
  98         c.Assert(err, IsNil)
  99
 100         os.Remove(newFile)
 101         err = s.bucket.GetObjectToFile(objectName, newFile)
 102         c.Assert(err, IsNil)
 103
 104         eq, err := compareFiles(fileName, newFile)
 105         c.Assert(err, IsNil)
 106         c.Assert(eq, Equals, true)
 107
 108         err = s.bucket.DeleteObject(objectName)
 109         c.Assert(err, IsNil)
 110
 111         // Specify routine count as 1
 112         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(1))
 113         c.Assert(err, IsNil)
 114
 115         os.Remove(newFile)
 116         err = s.bucket.GetObjectToFile(objectName, newFile)
 117         c.Assert(err, IsNil)
 118
 119         eq, err = compareFiles(fileName, newFile)
 120         c.Assert(err, IsNil)
 121         c.Assert(eq, Equals, true)
 122
 123         err = s.bucket.DeleteObject(objectName)
 124         c.Assert(err, IsNil)
 125
 126         // Specify routine count as 3, which is smaller than parts count 5
 127         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(3))
 128         c.Assert(err, IsNil)
 129
 130         os.Remove(newFile)
 131         err = s.bucket.GetObjectToFile(objectName, newFile)
 132         c.Assert(err, IsNil)
 133
 134         eq, err = compareFiles(fileName, newFile)
 135         c.Assert(err, IsNil)
 136         c.Assert(eq, Equals, true)
 137
 138         err = s.bucket.DeleteObject(objectName)
 139         c.Assert(err, IsNil)
 140
 141         // Specify routine count as 5, which is same as the part count 5
 142         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(5))
 143         c.Assert(err, IsNil)
 144
 145         os.Remove(newFile)
 146         err = s.bucket.GetObjectToFile(objectName, newFile)
 147         c.Assert(err, IsNil)
 148
 149         eq, err = compareFiles(fileName, newFile)
 150         c.Assert(err, IsNil)
 151         c.Assert(eq, Equals, true)
 152
 153         err = s.bucket.DeleteObject(objectName)
 154         c.Assert(err, IsNil)
 155
 156         // Specify routine count as 10, which is bigger than the part count 5.
 157         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(10))
 158         c.Assert(err, IsNil)
 159
 160         os.Remove(newFile)
 161         err = s.bucket.GetObjectToFile(objectName, newFile)
 162         c.Assert(err, IsNil)
 163
 164         eq, err = compareFiles(fileName, newFile)
 165         c.Assert(err, IsNil)
 166         c.Assert(eq, Equals, true)
 167
 168         err = s.bucket.DeleteObject(objectName)
 169         c.Assert(err, IsNil)
 170
 171         // Invalid routine count, it will use 1 automatically.
 172         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(0))
 173         os.Remove(newFile)
 174         err = s.bucket.GetObjectToFile(objectName, newFile)
 175         c.Assert(err, IsNil)
 176
 177         eq, err = compareFiles(fileName, newFile)
 178         c.Assert(err, IsNil)
 179         c.Assert(eq, Equals, true)
 180
 181         err = s.bucket.DeleteObject(objectName)
 182         c.Assert(err, IsNil)
 183
 184         // Invalid routine count, it will use 1 automatically
 185         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(-1))
 186         os.Remove(newFile)
 187         err = s.bucket.GetObjectToFile(objectName, newFile)
 188         c.Assert(err, IsNil)
 189
 190         eq, err = compareFiles(fileName, newFile)
 191         c.Assert(err, IsNil)
 192         c.Assert(eq, Equals, true)
 193
 194         err = s.bucket.DeleteObject(objectName)
 195         c.Assert(err, IsNil)
 196
 197         // Option
 198         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(3), Meta("myprop", "mypropval"))
 199
 200         meta, err := s.bucket.GetObjectDetailedMeta(objectName)
 201         c.Assert(err, IsNil)
 202         c.Assert(meta.Get("X-Oss-Meta-Myprop"), Equals, "mypropval")
 203
 204         os.Remove(newFile)
 205         err = s.bucket.GetObjectToFile(objectName, newFile)
 206         c.Assert(err, IsNil)
 207
 208         eq, err = compareFiles(fileName, newFile)
 209         c.Assert(err, IsNil)
 210         c.Assert(eq, Equals, true)
 211
 212         err = s.bucket.DeleteObject(objectName)
 213         c.Assert(err, IsNil)
 214 }
 215
 216 // ErrorHooker is a UploadPart hook---it will fail the 5th part's upload.
 217 func ErrorHooker(id int, chunk FileChunk) error {
 218         if chunk.Number == 5 {
 219                 time.Sleep(time.Second)
 220                 return fmt.Errorf("ErrorHooker")
 221         }
 222         return nil
 223 }
 224
 225 // TestUploadRoutineWithoutRecoveryNegative is multiroutineed upload without checkpoint
 226 func (s *OssUploadSuite) TestUploadRoutineWithoutRecoveryNegative(c *C) {
 227         objectName := objectNamePrefix + RandStr(8)
 228         fileName := "../sample/BingWallpaper-2015-11-07.jpg"
 229
 230         uploadPartHooker = ErrorHooker
 231         // Worker routine error
 232         err := s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(2))
 233         c.Assert(err, NotNil)
 234         c.Assert(err.Error(), Equals, "ErrorHooker")
 235         uploadPartHooker = defaultUploadPart
 236
 237         // Local file does not exist
 238         err = s.bucket.UploadFile(objectName, "NotExist", 100*1024, Routines(2))
 239         c.Assert(err, NotNil)
 240
 241         // The part size is invalid
 242         err = s.bucket.UploadFile(objectName, fileName, 1024, Routines(2))
 243         c.Assert(err, NotNil)
 244
 245         err = s.bucket.UploadFile(objectName, fileName, 1024*1024*1024*100, Routines(2))
 246         c.Assert(err, NotNil)
 247 }
 248
 249 // TestUploadRoutineWithRecovery is multi-routine upload with resumable recovery
 250 func (s *OssUploadSuite) TestUploadRoutineWithRecovery(c *C) {
 251         objectName := objectNamePrefix + RandStr(8)
 252         fileName := "../sample/BingWallpaper-2015-11-07.jpg"
 253         newFile := "upload-new-file-2.jpg"
 254
 255         // Use default routines and default CP file path (fileName+.cp)
 256         // First upload for 4 parts
 257         uploadPartHooker = ErrorHooker
 258         err := s.bucket.UploadFile(objectName, fileName, 100*1024, Checkpoint(true, fileName+".cp"))
 259         c.Assert(err, NotNil)
 260         c.Assert(err.Error(), Equals, "ErrorHooker")
 261         uploadPartHooker = defaultUploadPart
 262
 263         // Check CP
 264         ucp := uploadCheckpoint{}
 265         err = ucp.load(fileName + ".cp")
 266         c.Assert(err, IsNil)
 267         c.Assert(ucp.Magic, Equals, uploadCpMagic)
 268         c.Assert(len(ucp.MD5), Equals, len("LC34jZU5xK4hlxi3Qn3XGQ=="))
 269         c.Assert(ucp.FilePath, Equals, fileName)
 270         c.Assert(ucp.FileStat.Size, Equals, int64(482048))
 271         c.Assert(len(ucp.FileStat.LastModified.String()) > 0, Equals, true)
 272         c.Assert(ucp.FileStat.MD5, Equals, "")
 273         c.Assert(ucp.ObjectKey, Equals, objectName)
 274         c.Assert(len(ucp.UploadID), Equals, len("3F79722737D1469980DACEDCA325BB52"))
 275         c.Assert(len(ucp.Parts), Equals, 5)
 276         c.Assert(len(ucp.todoParts()), Equals, 1)
 277         c.Assert(len(ucp.allParts()), Equals, 5)
 278
 279         // Second upload, finish the remaining part
 280         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Checkpoint(true, fileName+".cp"))
 281         c.Assert(err, IsNil)
 282
 283         os.Remove(newFile)
 284         err = s.bucket.GetObjectToFile(objectName, newFile)
 285         c.Assert(err, IsNil)
 286
 287         eq, err := compareFiles(fileName, newFile)
 288         c.Assert(err, IsNil)
 289         c.Assert(eq, Equals, true)
 290
 291         err = s.bucket.DeleteObject(objectName)
 292         c.Assert(err, IsNil)
 293
 294         err = ucp.load(fileName + ".cp")
 295         c.Assert(err, NotNil)
 296
 297         // Resumable upload with empty checkpoint path
 298         uploadPartHooker = ErrorHooker
 299         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(3), CheckpointDir(true, ""))
 300         c.Assert(err, NotNil)
 301         c.Assert(err.Error(), Equals, "ErrorHooker")
 302         uploadPartHooker = defaultUploadPart
 303         ucp = uploadCheckpoint{}
 304         err = ucp.load(fileName + ".cp")
 305         c.Assert(err, NotNil)
 306
 307         // Resumable upload with checkpoint dir
 308         uploadPartHooker = ErrorHooker
 309         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(3), CheckpointDir(true, "./"))
 310         c.Assert(err, NotNil)
 311         c.Assert(err.Error(), Equals, "ErrorHooker")
 312         uploadPartHooker = defaultUploadPart
 313
 314         // Check CP
 315         ucp = uploadCheckpoint{}
 316         cpConf := cpConfig{IsEnable: true, DirPath: "./"}
 317         cpFilePath := getUploadCpFilePath(&cpConf, fileName, s.bucket.BucketName, objectName)
 318         err = ucp.load(cpFilePath)
 319         c.Assert(err, IsNil)
 320         c.Assert(ucp.Magic, Equals, uploadCpMagic)
 321         c.Assert(len(ucp.MD5), Equals, len("LC34jZU5xK4hlxi3Qn3XGQ=="))
 322         c.Assert(ucp.FilePath, Equals, fileName)
 323         c.Assert(ucp.FileStat.Size, Equals, int64(482048))
 324         c.Assert(len(ucp.FileStat.LastModified.String()) > 0, Equals, true)
 325         c.Assert(ucp.FileStat.MD5, Equals, "")
 326         c.Assert(ucp.ObjectKey, Equals, objectName)
 327         c.Assert(len(ucp.UploadID), Equals, len("3F79722737D1469980DACEDCA325BB52"))
 328         c.Assert(len(ucp.Parts), Equals, 5)
 329         c.Assert(len(ucp.todoParts()), Equals, 1)
 330         c.Assert(len(ucp.allParts()), Equals, 5)
 331
 332         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(3), CheckpointDir(true, "./"))
 333         c.Assert(err, IsNil)
 334
 335         os.Remove(newFile)
 336         err = s.bucket.GetObjectToFile(objectName, newFile)
 337         c.Assert(err, IsNil)
 338
 339         eq, err = compareFiles(fileName, newFile)
 340         c.Assert(err, IsNil)
 341         c.Assert(eq, Equals, true)
 342
 343         err = s.bucket.DeleteObject(objectName)
 344         c.Assert(err, IsNil)
 345
 346         err = ucp.load(cpFilePath)
 347         c.Assert(err, NotNil)
 348
 349         // Upload all 5 parts without error
 350         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(3), Checkpoint(true, objectName+".cp"))
 351         c.Assert(err, IsNil)
 352
 353         os.Remove(newFile)
 354         err = s.bucket.GetObjectToFile(objectName, newFile)
 355         c.Assert(err, IsNil)
 356
 357         eq, err = compareFiles(fileName, newFile)
 358         c.Assert(err, IsNil)
 359         c.Assert(eq, Equals, true)
 360
 361         err = s.bucket.DeleteObject(objectName)
 362         c.Assert(err, IsNil)
 363
 364         // Upload all 5 parts with 10 routines without error
 365         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(10), Checkpoint(true, objectName+".cp"))
 366         c.Assert(err, IsNil)
 367
 368         os.Remove(newFile)
 369         err = s.bucket.GetObjectToFile(objectName, newFile)
 370         c.Assert(err, IsNil)
 371
 372         eq, err = compareFiles(fileName, newFile)
 373         c.Assert(err, IsNil)
 374         c.Assert(eq, Equals, true)
 375
 376         err = s.bucket.DeleteObject(objectName)
 377         c.Assert(err, IsNil)
 378
 379         // Option
 380         err = s.bucket.UploadFile(objectName, fileName, 100*1024, Routines(3), Checkpoint(true, objectName+".cp"), Meta("myprop", "mypropval"))
 381
 382         meta, err := s.bucket.GetObjectDetailedMeta(objectName)
 383         c.Assert(err, IsNil)
 384         c.Assert(meta.Get("X-Oss-Meta-Myprop"), Equals, "mypropval")
 385
 386         os.Remove(newFile)
 387         err = s.bucket.GetObjectToFile(objectName, newFile)
 388         c.Assert(err, IsNil)
 389
 390         eq, err = compareFiles(fileName, newFile)
 391         c.Assert(err, IsNil)
 392         c.Assert(eq, Equals, true)
 393
 394         err = s.bucket.DeleteObject(objectName)
 395         c.Assert(err, IsNil)
 396 }
 397
 398 // TestUploadRoutineWithRecoveryNegative is multiroutineed upload without checkpoint
 399 func (s *OssUploadSuite) TestUploadRoutineWithRecoveryNegative(c *C) {
 400         objectName := objectNamePrefix + RandStr(8)
 401         fileName := "../sample/BingWallpaper-2015-11-07.jpg"
 402
 403         // The local file does not exist
 404         err := s.bucket.UploadFile(objectName, "NotExist", 100*1024, Checkpoint(true, "NotExist.cp"))
 405         c.Assert(err, NotNil)
 406
 407         err = s.bucket.UploadFile(objectName, "NotExist", 100*1024, Routines(2), Checkpoint(true, "NotExist.cp"))
 408         c.Assert(err, NotNil)
 409
 410         // Specified part size is invalid
 411         err = s.bucket.UploadFile(objectName, fileName, 1024, Checkpoint(true, fileName+".cp"))
 412         c.Assert(err, NotNil)
 413
 414         err = s.bucket.UploadFile(objectName, fileName, 1024, Routines(2), Checkpoint(true, fileName+".cp"))
 415         c.Assert(err, NotNil)
 416
 417         err = s.bucket.UploadFile(objectName, fileName, 1024*1024*1024*100, Checkpoint(true, fileName+".cp"))
 418         c.Assert(err, NotNil)
 419
 420         err = s.bucket.UploadFile(objectName, fileName, 1024*1024*1024*100, Routines(2), Checkpoint(true, fileName+".cp"))
 421         c.Assert(err, NotNil)
 422 }
 423
 424 // TestUploadLocalFileChange tests the file is updated while being uploaded
 425 func (s *OssUploadSuite) TestUploadLocalFileChange(c *C) {
 426         objectName := objectNamePrefix + RandStr(8)
 427         fileName := "../sample/BingWallpaper-2015-11-07.jpg"
 428         localFile := RandStr(8) + ".jpg"
 429         newFile := RandStr(8) + ".jpg"
 430
 431         os.Remove(localFile)
 432         err := copyFile(fileName, localFile)
 433         c.Assert(err, IsNil)
 434
 435         // First upload for 4 parts
 436         uploadPartHooker = ErrorHooker
 437         err = s.bucket.UploadFile(objectName, localFile, 100*1024, Checkpoint(true, localFile+".cp"))
 438         c.Assert(err, NotNil)
 439         c.Assert(err.Error(), Equals, "ErrorHooker")
 440         uploadPartHooker = defaultUploadPart
 441
 442         os.Remove(localFile)
 443         err = copyFile(fileName, localFile)
 444         c.Assert(err, IsNil)
 445
 446         // Updating the file. The second upload will re-upload all 5 parts.
 447         err = s.bucket.UploadFile(objectName, localFile, 100*1024, Checkpoint(true, localFile+".cp"))
 448         c.Assert(err, IsNil)
 449
 450         os.Remove(newFile)
 451         err = s.bucket.GetObjectToFile(objectName, newFile)
 452         c.Assert(err, IsNil)
 453
 454         eq, err := compareFiles(fileName, newFile)
 455         c.Assert(err, IsNil)
 456         c.Assert(eq, Equals, true)
 457
 458         err = s.bucket.DeleteObject(objectName)
 459         c.Assert(err, IsNil)
 460 }
 461
 462 // TestUploadPartArchiveObject
 463 func (s *OssUploadSuite) TestUploadPartArchiveObject(c *C) {
 464         // create archive bucket
 465         client, err := New(endpoint, accessID, accessKey)
 466         c.Assert(err, IsNil)
 467
 468         bucketName := bucketNamePrefix + RandLowStr(6)
 469         err = client.CreateBucket(bucketName, StorageClass(StorageArchive))
 470         c.Assert(err, IsNil)
 471         bucket, err := client.Bucket(bucketName)
 472         objectName := objectNamePrefix + RandStr(8)
 473
 474         fileName := "../sample/BingWallpaper-2015-11-07.jpg"
 475         fileInfo, err := os.Stat(fileName)
 476         c.Assert(err, IsNil)
 477
 478         // Updating the file,archive object
 479         err = bucket.UploadFile(objectName, fileName, fileInfo.Size()/2, ObjectStorageClass(StorageArchive))
 480         c.Assert(err, IsNil)
 481
 482         // Updating the file,archive object,checkpoint
 483         err = bucket.UploadFile(objectName, fileName, fileInfo.Size()/2, ObjectStorageClass(StorageArchive), Checkpoint(true, fileName+".cp"))
 484         c.Assert(err, IsNil)
 485         ForceDeleteBucket(client, bucketName, c)
 486 }
 487
 488 func copyFile(src, dst string) error {
 489         srcFile, err := os.Open(src)
 490         if err != nil {
 491                 return err
 492         }
 493         defer srcFile.Close()
 494
 495         dstFile, err := os.Create(dst)
 496         if err != nil {
 497                 return err
 498         }
 499         defer dstFile.Close()
 500
 501         _, err = io.Copy(dstFile, srcFile)
 502         return err
 503 }
 504
 505 func (s *OssUploadSuite) TestVersioningUploadRoutineWithRecovery(c *C) {
 506         // create a bucket with default proprety
 507         client, err := New(endpoint, accessID, accessKey)
 508         c.Assert(err, IsNil)
 509
 510         bucketName := bucketNamePrefix + RandLowStr(6)
 511         err = client.CreateBucket(bucketName)
 512         c.Assert(err, IsNil)
 513
 514         bucket, err := client.Bucket(bucketName)
 515
 516         // put bucket version:enabled
 517         var versioningConfig VersioningConfig
 518         versioningConfig.Status = string(VersionEnabled)
 519         err = client.SetBucketVersioning(bucketName, versioningConfig)
 520         c.Assert(err, IsNil)
 521
 522         // begin test
 523         objectName := objectNamePrefix + RandStr(8)
 524         fileName := "test-file-" + RandStr(8)
 525         fileData := RandStr(500 * 1024)
 526         CreateFile(fileName, fileData, c)
 527         newFile := "test-file-" + RandStr(8)
 528
 529         // Use default routines and default CP file path (fileName+.cp)Header
 530         // First upload for 4 parts
 531         var respHeader http.Header
 532         uploadPartHooker = ErrorHooker
 533         options := []Option{Checkpoint(true, fileName+".cp"), GetResponseHeader(&respHeader)}
 534         err = bucket.UploadFile(objectName, fileName, 100*1024, options...)
 535         c.Assert(err, NotNil)
 536         c.Assert(err.Error(), Equals, "ErrorHooker")
 537         c.Assert(GetVersionId(respHeader), Equals, "")
 538
 539         uploadPartHooker = defaultUploadPart
 540
 541         // Second upload, finish the remaining part
 542         options = []Option{Checkpoint(true, fileName+".cp"), GetResponseHeader(&respHeader)}
 543         err = bucket.UploadFile(objectName, fileName, 100*1024, options...)
 544         c.Assert(err, IsNil)
 545         versionIdUp := GetVersionId(respHeader)
 546         c.Assert(len(versionIdUp) > 0, Equals, true)
 547
 548         os.Remove(newFile)
 549         var respHeaderDown http.Header
 550         err = bucket.GetObjectToFile(objectName, newFile, GetResponseHeader(&respHeaderDown))
 551         versionIdDown := GetVersionId(respHeaderDown)
 552         c.Assert(err, IsNil)
 553         c.Assert(versionIdUp, Equals, versionIdDown)
 554
 555         eq, err := compareFiles(fileName, newFile)
 556         c.Assert(err, IsNil)
 557         c.Assert(eq, Equals, true)
 558
 559         os.Remove(fileName)
 560         os.Remove(newFile)
 561         bucket.DeleteObject(objectName)
 562         ForceDeleteBucket(client, bucketName, c)
 563 }
 564
 565 // TestUploadFileChoiceOptions
 566 func (s *OssUploadSuite) TestUploadFileChoiceOptions(c *C) {
 567         // create a bucket with default proprety
 568         client, err := New(endpoint, accessID, accessKey)
 569         c.Assert(err, IsNil)
 570
 571         bucketName := bucketNamePrefix + RandLowStr(6)
 572         err = client.CreateBucket(bucketName)
 573         c.Assert(err, IsNil)
 574         bucket, err := client.Bucket(bucketName)
 575
 576         fileName := "../sample/BingWallpaper-2015-11-07.jpg"
 577         fileInfo, err := os.Stat(fileName)
 578         c.Assert(err, IsNil)
 579
 580         objectName := objectNamePrefix + RandStr(8)
 581
 582         // UploadFile with properties
 583         options := []Option{
 584                 ObjectACL(ACLPublicRead),
 585                 RequestPayer(Requester),
 586                 TrafficLimitHeader(1024 * 1024 * 8),
 587                 ServerSideEncryption("AES256"),
 588                 ObjectStorageClass(StorageArchive),
 589         }
 590
 591         // Updating the file
 592         err = bucket.UploadFile(objectName, fileName, fileInfo.Size()/2, options...)
 593         c.Assert(err, IsNil)
 594
 595         // GetMetaDetail
 596         headerResp, err := bucket.GetObjectDetailedMeta(objectName)
 597         c.Assert(err, IsNil)
 598
 599         c.Assert(headerResp.Get("X-Oss-Server-Side-Encryption"), Equals, "AES256")
 600         aclResult, err := bucket.GetObjectACL(objectName)
 601         c.Assert(aclResult.ACL, Equals, "public-read")
 602         c.Assert(err, IsNil)
 603         ForceDeleteBucket(client, bucketName, c)
 604 }
 605
 606 // TestUploadFileWithCpChoiceOptions
 607 func (s *OssUploadSuite) TestUploadFileWithCpChoiceOptions(c *C) {
 608         // create a bucket with default proprety
 609         client, err := New(endpoint, accessID, accessKey)
 610         c.Assert(err, IsNil)
 611
 612         bucketName := bucketNamePrefix + RandLowStr(6)
 613         err = client.CreateBucket(bucketName)
 614         c.Assert(err, IsNil)
 615         bucket, err := client.Bucket(bucketName)
 616
 617         fileName := "../sample/BingWallpaper-2015-11-07.jpg"
 618         fileInfo, err := os.Stat(fileName)
 619         c.Assert(err, IsNil)
 620
 621         objectName := objectNamePrefix + RandStr(8)
 622
 623         // UploadFile with properties
 624         options := []Option{
 625                 ObjectACL(ACLPublicRead),
 626                 RequestPayer(Requester),
 627                 TrafficLimitHeader(1024 * 1024 * 8),
 628                 ServerSideEncryption("AES256"),
 629                 ObjectStorageClass(StorageArchive),
 630                 Checkpoint(true, fileName+".cp"), // with checkpoint
 631         }
 632
 633         // Updating the file
 634         err = bucket.UploadFile(objectName, fileName, fileInfo.Size()/2, options...)
 635         c.Assert(err, IsNil)
 636
 637         // GetMetaDetail
 638         headerResp, err := bucket.GetObjectDetailedMeta(objectName)
 639         c.Assert(err, IsNil)
 640
 641         c.Assert(headerResp.Get("X-Oss-Server-Side-Encryption"), Equals, "AES256")
 642         c.Assert(headerResp.Get("X-Oss-Storage-Class"), Equals, "Archive")
 643
 644         aclResult, err := bucket.GetObjectACL(objectName)
 645         c.Assert(aclResult.ACL, Equals, "public-read")
 646         c.Assert(err, IsNil)
 647
 648         ForceDeleteBucket(client, bucketName, c)
 649 }
 650
 651 // TestUploadFileWithForbidOverWrite
 652 func (s *OssUploadSuite) TestUploadFileWithForbidOverWrite(c *C) {
 653         // create a bucket with default proprety
 654         client, err := New(endpoint, accessID, accessKey)
 655         c.Assert(err, IsNil)
 656
 657         bucketName := bucketNamePrefix + RandLowStr(6)
 658         err = client.CreateBucket(bucketName)
 659         c.Assert(err, IsNil)
 660         bucket, err := client.Bucket(bucketName)
 661
 662         fileName := "../sample/BingWallpaper-2015-11-07.jpg"
 663         fileInfo, err := os.Stat(fileName)
 664         c.Assert(err, IsNil)
 665
 666         objectName := objectNamePrefix + RandStr(8)
 667
 668         // UploadFile with properties
 669         options := []Option{
 670                 ObjectACL(ACLPublicRead),
 671                 RequestPayer(Requester),
 672                 TrafficLimitHeader(1024 * 1024 * 8),
 673                 ServerSideEncryption("AES256"),
 674                 ObjectStorageClass(StorageArchive),
 675                 ForbidOverWrite(true),
 676                 Checkpoint(true, fileName+".cp"),
 677         }
 678
 679         // Updating the file
 680         err = bucket.UploadFile(objectName, fileName, fileInfo.Size()/2, options...)
 681         c.Assert(err, IsNil)
 682
 683         // Updating the file with ForbidOverWrite(true)
 684         err = bucket.UploadFile(objectName, fileName, fileInfo.Size()/2, options...)
 685         c.Assert(err, NotNil)
 686
 687         // without Checkpoint
 688         options = []Option{
 689                 ObjectACL(ACLPublicRead),
 690                 RequestPayer(Requester),
 691                 TrafficLimitHeader(1024 * 1024 * 8),
 692                 ServerSideEncryption("AES256"),
 693                 ObjectStorageClass(StorageArchive),
 694                 ForbidOverWrite(true),
 695         }
 696
 697         // Updating the file with ForbidOverWrite(true)
 698         err = bucket.UploadFile(objectName, fileName, fileInfo.Size()/2, options...)
 699         c.Assert(err, NotNil)
 700
 701         ForceDeleteBucket(client, bucketName, c)
 702 }
 703
 704 // TestUploadFileWithSequential
 705 func (s *OssUploadSuite) TestUploadFileWithSequential(c *C) {
 706         // create a bucket with default proprety
 707         client, err := New(endpoint, accessID, accessKey)
 708         c.Assert(err, IsNil)
 709
 710         bucketName := bucketNamePrefix + RandLowStr(6)
 711         err = client.CreateBucket(bucketName)
 712         c.Assert(err, IsNil)
 713         bucket, err := client.Bucket(bucketName)
 714
 715         fileName := "../sample/BingWallpaper-2015-11-07.jpg"
 716         fileInfo, err := os.Stat(fileName)
 717         c.Assert(err, IsNil)
 718
 719         objectName := objectNamePrefix + RandStr(8)
 720
 721         var respHeader http.Header
 722
 723         // UploadFile with properties
 724         options := []Option{
 725                 Sequential(),
 726                 GetResponseHeader(&respHeader),
 727                 Checkpoint(true, fileName+".cp"),
 728         }
 729
 730         // Updating the file
 731         err = bucket.UploadFile(objectName, fileName, fileInfo.Size()/2, options...)
 732         c.Assert(err, IsNil)
 733
 734         respHeader, err = bucket.GetObjectDetailedMeta(objectName)
 735         c.Assert(err, IsNil)
 736
 737         strMD5 := respHeader.Get("Content-MD5")
 738         c.Assert(len(strMD5) > 0, Equals, true)
 739
 740         ForceDeleteBucket(client, bucketName, c)
 741 }