vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/crypto/crypto_multipart_test.go

   1 // multipart test
   2
   3 package osscrypto
   4
   5 import (
   6         "io/ioutil"
   7         "os"
   8
   9         "github.com/aliyun/aliyun-oss-go-sdk/oss"
  10         . "gopkg.in/check.v1"
  11 )
  12
  13 func (s *OssCryptoBucketSuite) TestMultipartUpload(c *C) {
  14         // create a bucket with default proprety
  15         client, err := oss.New(endpoint, accessID, accessKey)
  16         c.Assert(err, IsNil)
  17
  18         bucketName := bucketNamePrefix + RandLowStr(6)
  19         err = client.CreateBucket(bucketName)
  20         c.Assert(err, IsNil)
  21
  22         // crypto bucket
  23         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
  24         contentProvider := CreateAesCtrCipher(masterRsaCipher)
  25         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
  26
  27         objectName := objectNamePrefix + RandStr(8)
  28         fileName := "../../sample/BingWallpaper-2015-11-07.jpg"
  29
  30         srcMD5, err := GetFileMD5(fileName)
  31         c.Assert(err, IsNil)
  32
  33         fileInfo, err := os.Stat(fileName)
  34         dataSize := fileInfo.Size()
  35         c.Assert(err, IsNil)
  36
  37         options := []oss.Option{oss.Meta("my", "myprop")}
  38         var cryptoContext PartCryptoContext
  39         cryptoContext.DataSize = dataSize
  40         cryptoContext.PartSize = (dataSize / 16 / 3) * 16
  41         imur, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext, options...)
  42         c.Assert(err, IsNil)
  43
  44         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
  45         c.Assert(err, IsNil)
  46
  47         fd, err := os.Open(fileName)
  48         c.Assert(err, IsNil)
  49         defer fd.Close()
  50
  51         var parts []oss.UploadPart
  52         for _, chunk := range chunks {
  53                 fd.Seek(chunk.Offset, os.SEEK_SET)
  54                 part, err := bucket.UploadPart(imur, fd, chunk.Size, chunk.Number, cryptoContext)
  55                 c.Assert(err, IsNil)
  56                 parts = append(parts, part)
  57         }
  58
  59         _, err = bucket.CompleteMultipartUpload(imur, parts)
  60         c.Assert(err, IsNil)
  61
  62         meta, err := bucket.GetObjectDetailedMeta(objectName)
  63         c.Assert(err, IsNil)
  64
  65         c.Assert(meta.Get("X-Oss-Meta-My"), Equals, "myprop")
  66         c.Assert(meta.Get("X-Oss-Object-Type"), Equals, "Multipart")
  67
  68         downfileName := "test-go-sdk-file-" + RandLowStr(5)
  69         err = bucket.GetObjectToFile(objectName, downfileName)
  70         c.Assert(err, IsNil)
  71
  72         downFileMD5, err := GetFileMD5(downfileName)
  73         c.Assert(err, IsNil)
  74         c.Assert(downFileMD5, Equals, srcMD5)
  75
  76         os.Remove(downfileName)
  77         ForceDeleteBucket(client, bucketName, c)
  78 }
  79
  80 func (s *OssCryptoBucketSuite) TestMultipartUploadFromFile(c *C) {
  81         // create a bucket with default proprety
  82         client, err := oss.New(endpoint, accessID, accessKey)
  83         c.Assert(err, IsNil)
  84
  85         bucketName := bucketNamePrefix + RandLowStr(6)
  86         err = client.CreateBucket(bucketName)
  87         c.Assert(err, IsNil)
  88
  89         // crypto bucket
  90         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
  91         contentProvider := CreateAesCtrCipher(masterRsaCipher)
  92         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
  93
  94         objectName := objectNamePrefix + RandStr(8)
  95         fileName := "../../sample/BingWallpaper-2015-11-07.jpg"
  96
  97         srcMD5, err := GetFileMD5(fileName)
  98         c.Assert(err, IsNil)
  99
 100         fileInfo, err := os.Stat(fileName)
 101         dataSize := fileInfo.Size()
 102         c.Assert(err, IsNil)
 103
 104         options := []oss.Option{oss.Meta("my", "myprop")}
 105         var cryptoContext PartCryptoContext
 106         cryptoContext.DataSize = dataSize
 107         cryptoContext.PartSize = (dataSize / 16 / 3) * 16
 108         imur, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext, options...)
 109         c.Assert(err, IsNil)
 110
 111         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
 112         c.Assert(err, IsNil)
 113
 114         var parts []oss.UploadPart
 115         for _, chunk := range chunks {
 116                 part, err := bucket.UploadPartFromFile(imur, fileName, chunk.Offset, chunk.Size, chunk.Number, cryptoContext)
 117                 c.Assert(err, IsNil)
 118                 parts = append(parts, part)
 119         }
 120
 121         _, err = bucket.CompleteMultipartUpload(imur, parts)
 122         c.Assert(err, IsNil)
 123
 124         meta, err := bucket.GetObjectDetailedMeta(objectName)
 125         c.Assert(err, IsNil)
 126
 127         c.Assert(meta.Get("X-Oss-Meta-My"), Equals, "myprop")
 128         c.Assert(meta.Get("X-Oss-Object-Type"), Equals, "Multipart")
 129
 130         downfileName := "test-go-sdk-file-" + RandLowStr(5) + ".jpg"
 131         err = bucket.GetObjectToFile(objectName, downfileName)
 132         c.Assert(err, IsNil)
 133
 134         downFileMD5, err := GetFileMD5(downfileName)
 135         c.Assert(err, IsNil)
 136         c.Assert(downFileMD5, Equals, srcMD5)
 137
 138         os.Remove(downfileName)
 139         ForceDeleteBucket(client, bucketName, c)
 140 }
 141
 142 func (s *OssCryptoBucketSuite) TestMultipartUploadFromSmallSizeFile(c *C) {
 143         // create a bucket with default proprety
 144         client, err := oss.New(endpoint, accessID, accessKey)
 145         c.Assert(err, IsNil)
 146
 147         bucketName := bucketNamePrefix + RandLowStr(6)
 148         err = client.CreateBucket(bucketName)
 149         c.Assert(err, IsNil)
 150
 151         // crypto bucket
 152         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
 153         contentProvider := CreateAesCtrCipher(masterRsaCipher)
 154         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
 155
 156         objectName := objectNamePrefix + RandStr(8)
 157         fileName := "oss-go-sdk-test-file-" + RandStr(5)
 158         fo, err := os.Create(fileName)
 159         c.Assert(err, IsNil)
 160         _, err = fo.Write([]byte("123"))
 161         c.Assert(err, IsNil)
 162         fo.Close()
 163
 164         srcMD5, err := GetFileMD5(fileName)
 165         c.Assert(err, IsNil)
 166
 167         fileInfo, err := os.Stat(fileName)
 168         dataSize := fileInfo.Size()
 169         c.Assert(err, IsNil)
 170
 171         options := []oss.Option{oss.Meta("my", "myprop")}
 172         var cryptoContext PartCryptoContext
 173         cryptoContext.DataSize = dataSize
 174         cryptoContext.PartSize = 16
 175         imur, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext, options...)
 176         c.Assert(err, IsNil)
 177
 178         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
 179         c.Assert(err, IsNil)
 180
 181         var parts []oss.UploadPart
 182         for _, chunk := range chunks {
 183                 part, err := bucket.UploadPartFromFile(imur, fileName, chunk.Offset, chunk.Size, chunk.Number, cryptoContext)
 184                 c.Assert(err, IsNil)
 185                 parts = append(parts, part)
 186         }
 187
 188         _, err = bucket.CompleteMultipartUpload(imur, parts)
 189         c.Assert(err, IsNil)
 190
 191         meta, err := bucket.GetObjectDetailedMeta(objectName)
 192         c.Assert(err, IsNil)
 193
 194         c.Assert(meta.Get("X-Oss-Meta-My"), Equals, "myprop")
 195         c.Assert(meta.Get("X-Oss-Object-Type"), Equals, "Multipart")
 196
 197         downfileName := "test-go-sdk-file-" + RandLowStr(5) + ".jpg"
 198         err = bucket.GetObjectToFile(objectName, downfileName)
 199         c.Assert(err, IsNil)
 200
 201         downFileMD5, err := GetFileMD5(downfileName)
 202         c.Assert(err, IsNil)
 203         c.Assert(downFileMD5, Equals, srcMD5)
 204
 205         os.Remove(fileName)
 206         os.Remove(downfileName)
 207         ForceDeleteBucket(client, bucketName, c)
 208 }
 209
 210 func (s *OssCryptoBucketSuite) TestListUploadedPartsNormal(c *C) {
 211         // create a bucket with default proprety
 212         client, err := oss.New(endpoint, accessID, accessKey)
 213         c.Assert(err, IsNil)
 214
 215         bucketName := bucketNamePrefix + RandLowStr(6)
 216         err = client.CreateBucket(bucketName)
 217         c.Assert(err, IsNil)
 218
 219         // crypto bucket
 220         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
 221         contentProvider := CreateAesCtrCipher(masterRsaCipher)
 222         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
 223
 224         objectName := objectNamePrefix + RandStr(8)
 225         fileName := "../../sample/BingWallpaper-2015-11-07.jpg"
 226
 227         srcMD5, err := GetFileMD5(fileName)
 228         c.Assert(err, IsNil)
 229
 230         fileInfo, err := os.Stat(fileName)
 231         dataSize := fileInfo.Size()
 232         c.Assert(err, IsNil)
 233
 234         // Upload
 235         var cryptoContext PartCryptoContext
 236         cryptoContext.DataSize = dataSize
 237         cryptoContext.PartSize = (dataSize / 16 / 3) * 16
 238         imurUpload, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext)
 239         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
 240         c.Assert(err, IsNil)
 241
 242         var partsUpload []oss.UploadPart
 243         for _, chunk := range chunks {
 244                 part, err := bucket.UploadPartFromFile(imurUpload, fileName, chunk.Offset, chunk.Size, (int)(chunk.Number), cryptoContext)
 245                 c.Assert(err, IsNil)
 246                 partsUpload = append(partsUpload, part)
 247         }
 248
 249         // List
 250         lupr, err := bucket.ListUploadedParts(imurUpload)
 251         c.Assert(err, IsNil)
 252         c.Assert(len(lupr.UploadedParts), Equals, len(chunks))
 253
 254         // Complete
 255         _, err = bucket.CompleteMultipartUpload(imurUpload, partsUpload)
 256         c.Assert(err, IsNil)
 257
 258         // Download
 259         downfileName := "test-go-sdk-file-" + RandLowStr(5) + ".jpg"
 260         err = bucket.GetObjectToFile(objectName, downfileName)
 261
 262         downFileMD5, err := GetFileMD5(downfileName)
 263         c.Assert(err, IsNil)
 264         c.Assert(downFileMD5, Equals, srcMD5)
 265
 266         os.Remove(downfileName)
 267         ForceDeleteBucket(client, bucketName, c)
 268 }
 269
 270 func (s *OssCryptoBucketSuite) TestListUploadedPartsComplete(c *C) {
 271         // create a bucket with default proprety
 272         client, err := oss.New(endpoint, accessID, accessKey)
 273         c.Assert(err, IsNil)
 274
 275         bucketName := bucketNamePrefix + RandLowStr(6)
 276         err = client.CreateBucket(bucketName)
 277         c.Assert(err, IsNil)
 278
 279         // crypto bucket
 280         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
 281         contentProvider := CreateAesCtrCipher(masterRsaCipher)
 282         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
 283
 284         objectName := objectNamePrefix + RandStr(8)
 285         fileName := "../../sample/BingWallpaper-2015-11-07.jpg"
 286
 287         srcMD5, err := GetFileMD5(fileName)
 288         c.Assert(err, IsNil)
 289
 290         fileInfo, err := os.Stat(fileName)
 291         dataSize := fileInfo.Size()
 292         c.Assert(err, IsNil)
 293
 294         // Upload
 295         var cryptoContext PartCryptoContext
 296         cryptoContext.DataSize = dataSize
 297         cryptoContext.PartSize = (dataSize / 16 / 3) * 16
 298         imurUpload, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext)
 299         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
 300         c.Assert(err, IsNil)
 301
 302         var partsUpload []oss.UploadPart
 303         i := 0
 304         // upload excepted the last part
 305         for ; i < len(chunks)-1; i++ {
 306                 part, err := bucket.UploadPartFromFile(imurUpload, fileName, chunks[i].Offset, chunks[i].Size, (int)(chunks[i].Number), cryptoContext)
 307                 c.Assert(err, IsNil)
 308                 partsUpload = append(partsUpload, part)
 309         }
 310
 311         // List
 312         lupr, err := bucket.ListUploadedParts(imurUpload)
 313         c.Assert(err, IsNil)
 314         c.Assert(len(lupr.UploadedParts), Equals, len(chunks)-1)
 315
 316         lmur, err := bucket.ListMultipartUploads()
 317         c.Assert(err, IsNil)
 318         c.Assert(len(lmur.Uploads), Equals, 1)
 319
 320         // upload the last part with list part result
 321         part, err := bucket.UploadPartFromFile(imurUpload, fileName, chunks[i].Offset, chunks[i].Size, (int)(chunks[i].Number), cryptoContext)
 322         c.Assert(err, IsNil)
 323         partsUpload = append(partsUpload, part)
 324
 325         // Complete
 326         _, err = bucket.CompleteMultipartUpload(imurUpload, partsUpload)
 327         c.Assert(err, IsNil)
 328
 329         // Download
 330         downfileName := "test-go-sdk-file-" + RandLowStr(5) + ".jpg"
 331         err = bucket.GetObjectToFile(objectName, downfileName)
 332
 333         downFileMD5, err := GetFileMD5(downfileName)
 334         c.Assert(err, IsNil)
 335         c.Assert(downFileMD5, Equals, srcMD5)
 336
 337         os.Remove(downfileName)
 338         ForceDeleteBucket(client, bucketName, c)
 339 }
 340
 341 func (s *OssCryptoBucketSuite) TestListUploadedPartsAbortUseInit(c *C) {
 342         // create a bucket with default proprety
 343         client, err := oss.New(endpoint, accessID, accessKey)
 344         c.Assert(err, IsNil)
 345
 346         bucketName := bucketNamePrefix + RandLowStr(6)
 347         err = client.CreateBucket(bucketName)
 348         c.Assert(err, IsNil)
 349
 350         // crypto bucket
 351         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
 352         contentProvider := CreateAesCtrCipher(masterRsaCipher)
 353         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
 354
 355         objectName := objectNamePrefix + RandStr(8)
 356         fileName := "../../sample/BingWallpaper-2015-11-07.jpg"
 357
 358         fileInfo, err := os.Stat(fileName)
 359         dataSize := fileInfo.Size()
 360         c.Assert(err, IsNil)
 361
 362         // Upload
 363         var cryptoContext PartCryptoContext
 364         cryptoContext.DataSize = dataSize
 365         cryptoContext.PartSize = (dataSize / 16 / 3) * 16
 366         imurUpload, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext)
 367         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
 368         c.Assert(err, IsNil)
 369         c.Assert(cryptoContext.Valid(), Equals, true)
 370
 371         var partsUpload []oss.UploadPart
 372         i := 0
 373         // upload excepted the last part
 374         for ; i < len(chunks)-1; i++ {
 375                 part, err := bucket.UploadPartFromFile(imurUpload, fileName, chunks[i].Offset, chunks[i].Size, (int)(chunks[i].Number), cryptoContext)
 376                 c.Assert(err, IsNil)
 377                 partsUpload = append(partsUpload, part)
 378         }
 379
 380         // List
 381         lupr, err := bucket.ListUploadedParts(imurUpload)
 382         c.Assert(err, IsNil)
 383         c.Assert(len(lupr.UploadedParts), Equals, len(chunks)-1)
 384
 385         lmur, err := bucket.ListMultipartUploads()
 386         c.Assert(err, IsNil)
 387         c.Assert(len(lmur.Uploads), Equals, 1)
 388
 389         // abort upload
 390         err = bucket.AbortMultipartUpload(imurUpload)
 391         c.Assert(err, IsNil)
 392
 393         // list again
 394         lupr, err = bucket.ListUploadedParts(imurUpload)
 395         c.Assert(err, NotNil)
 396
 397         ForceDeleteBucket(client, bucketName, c)
 398 }
 399
 400 func (s *OssCryptoBucketSuite) TestListUploadedPartsAbortUseList(c *C) {
 401         // create a bucket with default proprety
 402         client, err := oss.New(endpoint, accessID, accessKey)
 403         c.Assert(err, IsNil)
 404
 405         bucketName := bucketNamePrefix + RandLowStr(6)
 406         err = client.CreateBucket(bucketName)
 407         c.Assert(err, IsNil)
 408
 409         // crypto bucket
 410         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
 411         contentProvider := CreateAesCtrCipher(masterRsaCipher)
 412         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
 413
 414         objectName := objectNamePrefix + RandStr(8)
 415         fileName := "../../sample/BingWallpaper-2015-11-07.jpg"
 416
 417         fileInfo, err := os.Stat(fileName)
 418         dataSize := fileInfo.Size()
 419         c.Assert(err, IsNil)
 420
 421         // Upload
 422         var cryptoContext PartCryptoContext
 423         cryptoContext.DataSize = dataSize
 424         cryptoContext.PartSize = (dataSize / 16 / 3) * 16
 425         imurUpload, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext)
 426         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
 427         c.Assert(err, IsNil)
 428
 429         var partsUpload []oss.UploadPart
 430         i := 0
 431         // upload excepted the last part
 432         for ; i < len(chunks)-1; i++ {
 433                 part, err := bucket.UploadPartFromFile(imurUpload, fileName, chunks[i].Offset, chunks[i].Size, (int)(chunks[i].Number), cryptoContext)
 434                 c.Assert(err, IsNil)
 435                 partsUpload = append(partsUpload, part)
 436         }
 437
 438         // List
 439         lupr, err := bucket.ListUploadedParts(imurUpload)
 440         c.Assert(err, IsNil)
 441         c.Assert(len(lupr.UploadedParts), Equals, len(chunks)-1)
 442
 443         // abort upload
 444         err = bucket.AbortMultipartUpload(imurUpload)
 445         c.Assert(err, IsNil)
 446
 447         // list again
 448         lupr, err = bucket.ListUploadedParts(imurUpload)
 449         c.Assert(err, NotNil)
 450
 451         ForceDeleteBucket(client, bucketName, c)
 452 }
 453
 454 func (s *OssCryptoBucketSuite) TestInitiateMultipartUpload(c *C) {
 455         // create a bucket with default proprety
 456         client, err := oss.New(endpoint, accessID, accessKey)
 457         c.Assert(err, IsNil)
 458
 459         bucketName := bucketNamePrefix + RandLowStr(6)
 460         err = client.CreateBucket(bucketName)
 461         c.Assert(err, IsNil)
 462
 463         // crypto bucket
 464         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
 465         contentProvider := CreateAesCtrCipher(masterRsaCipher)
 466         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
 467
 468         objectName := objectNamePrefix + RandStr(8)
 469         context := RandStr(ivSize * 1024 * 10)
 470         fileName := "test-go-sdk-file-" + RandStr(5)
 471
 472         err = ioutil.WriteFile(fileName, []byte(context), 0666)
 473         c.Assert(err, IsNil)
 474
 475         fileInfo, err := os.Stat(fileName)
 476         dataSize := fileInfo.Size()
 477         c.Assert(err, IsNil)
 478
 479         var cryptoContext PartCryptoContext
 480         cryptoContext.DataSize = dataSize
 481         cryptoContext.PartSize = ivSize * 1024
 482         imurUpload, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext)
 483         c.Assert(err, IsNil)
 484
 485         err = bucket.AbortMultipartUpload(imurUpload)
 486         c.Assert(err, IsNil)
 487
 488         cryptoContext.DataSize = dataSize
 489         cryptoContext.PartSize = ivSize / 2
 490         imurUpload, err = bucket.InitiateMultipartUpload(objectName, &cryptoContext)
 491         c.Assert(err, NotNil)
 492
 493         os.Remove(fileName)
 494
 495         ForceDeleteBucket(client, bucketName, c)
 496 }
 497
 498 func (s *OssCryptoBucketSuite) TestUploadPartError(c *C) {
 499         // create a bucket with default proprety
 500         client, err := oss.New(endpoint, accessID, accessKey)
 501         c.Assert(err, IsNil)
 502
 503         bucketName := bucketNamePrefix + RandLowStr(6)
 504         err = client.CreateBucket(bucketName)
 505         c.Assert(err, IsNil)
 506
 507         // crypto bucket
 508         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
 509         contentProvider := CreateAesCtrCipher(masterRsaCipher)
 510         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
 511
 512         objectName := objectNamePrefix + RandStr(8)
 513         context := RandStr(ivSize * 1024 * 10)
 514         fileName := "test-go-sdk-file-" + RandStr(5)
 515
 516         err = ioutil.WriteFile(fileName, []byte(context), 0666)
 517         c.Assert(err, IsNil)
 518
 519         fileInfo, err := os.Stat(fileName)
 520         dataSize := fileInfo.Size()
 521         c.Assert(err, IsNil)
 522
 523         var cryptoContext PartCryptoContext
 524         cryptoContext.DataSize = dataSize
 525         cryptoContext.PartSize = ivSize * 1024
 526         imur, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext)
 527         c.Assert(err, IsNil)
 528
 529         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
 530         c.Assert(err, IsNil)
 531
 532         fd, err := os.Open(fileName)
 533         c.Assert(err, IsNil)
 534         for _, chunk := range chunks {
 535                 fd.Seek(chunk.Offset, os.SEEK_SET)
 536                 _, err := bucket.UploadPart(imur, fd, chunk.Size+1, chunk.Number, cryptoContext)
 537                 c.Assert(err, NotNil)
 538         }
 539
 540         for _, chunk := range chunks {
 541                 fd.Seek(chunk.Offset, os.SEEK_SET)
 542                 _, err := bucket.UploadPart(imur, fd, chunk.Size, 0, cryptoContext)
 543                 c.Assert(err, NotNil)
 544         }
 545         fd.Close()
 546
 547         err = bucket.AbortMultipartUpload(imur)
 548         c.Assert(err, IsNil)
 549         os.Remove(fileName)
 550         ForceDeleteBucket(client, bucketName, c)
 551 }
 552
 553 func (s *OssCryptoBucketSuite) TestUploadPartFromFileError(c *C) {
 554         // create a bucket with default proprety
 555         client, err := oss.New(endpoint, accessID, accessKey)
 556         c.Assert(err, IsNil)
 557
 558         bucketName := bucketNamePrefix + RandLowStr(6)
 559         err = client.CreateBucket(bucketName)
 560         c.Assert(err, IsNil)
 561
 562         // crypto bucket
 563         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
 564         contentProvider := CreateAesCtrCipher(masterRsaCipher)
 565         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
 566
 567         objectName := objectNamePrefix + RandStr(8)
 568         context := RandStr(ivSize * 1024 * 10)
 569         fileName := "test-go-sdk-file-" + RandStr(5)
 570
 571         err = ioutil.WriteFile(fileName, []byte(context), 0666)
 572         c.Assert(err, IsNil)
 573
 574         fileInfo, err := os.Stat(fileName)
 575         dataSize := fileInfo.Size()
 576         c.Assert(err, IsNil)
 577
 578         var cryptoContext PartCryptoContext
 579         cryptoContext.DataSize = dataSize
 580         cryptoContext.PartSize = ivSize * 1024
 581         imur, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext)
 582         c.Assert(err, IsNil)
 583
 584         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
 585         c.Assert(err, IsNil)
 586
 587         for _, chunk := range chunks {
 588                 _, err := bucket.UploadPartFromFile(imur, fileName+".test", chunk.Offset, chunk.Size, chunk.Number, cryptoContext)
 589                 c.Assert(err, NotNil)
 590         }
 591
 592         _, err = bucket.UploadPartFromFile(imur, fileName+".test", chunks[0].Offset, chunks[0].Size+1, chunks[0].Number, cryptoContext)
 593         c.Assert(err, NotNil)
 594
 595         _, err = bucket.UploadPartFromFile(imur, fileName+".test", chunks[0].Offset, chunks[0].Size, 0, cryptoContext)
 596         c.Assert(err, NotNil)
 597
 598         err = bucket.AbortMultipartUpload(imur)
 599         c.Assert(err, IsNil)
 600         os.Remove(fileName)
 601         ForceDeleteBucket(client, bucketName, c)
 602 }
 603
 604 func (s *OssCryptoBucketSuite) TestUploadPartCopyError(c *C) {
 605         // create a bucket with default proprety
 606         client, err := oss.New(endpoint, accessID, accessKey)
 607         c.Assert(err, IsNil)
 608
 609         bucketName := bucketNamePrefix + RandLowStr(6)
 610         err = client.CreateBucket(bucketName)
 611         c.Assert(err, IsNil)
 612
 613         // crypto bucket
 614         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
 615         contentProvider := CreateAesCtrCipher(masterRsaCipher)
 616         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
 617
 618         objectName := objectNamePrefix + RandStr(8)
 619         context := RandStr(ivSize * 1024 * 10)
 620         fileName := "test-go-sdk-file-" + RandStr(5)
 621
 622         err = ioutil.WriteFile(fileName, []byte(context), 0666)
 623         c.Assert(err, IsNil)
 624
 625         fileInfo, err := os.Stat(fileName)
 626         dataSize := fileInfo.Size()
 627         c.Assert(err, IsNil)
 628
 629         var cryptoContext PartCryptoContext
 630         cryptoContext.DataSize = dataSize
 631         cryptoContext.PartSize = ivSize * 1024
 632         imur, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext)
 633         c.Assert(err, IsNil)
 634
 635         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
 636         c.Assert(err, IsNil)
 637
 638         _, err = bucket.UploadPartCopy(imur, bucketName, objectName, 0, chunks[0].Size, 1, cryptoContext)
 639         c.Assert(err, NotNil)
 640
 641         err = bucket.AbortMultipartUpload(imur)
 642         c.Assert(err, IsNil)
 643         os.Remove(fileName)
 644         ForceDeleteBucket(client, bucketName, c)
 645 }
 646
 647 func (s *OssCryptoBucketSuite) TestMultipartUploadFromFileError(c *C) {
 648         // create a bucket with default proprety
 649         client, err := oss.New(endpoint, accessID, accessKey)
 650         c.Assert(err, IsNil)
 651
 652         bucketName := bucketNamePrefix + RandLowStr(6)
 653         err = client.CreateBucket(bucketName)
 654         c.Assert(err, IsNil)
 655
 656         // crypto bucket
 657         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
 658         contentProvider := CreateAesCtrCipher(masterRsaCipher)
 659         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
 660
 661         objectName := objectNamePrefix + RandStr(8)
 662         fileName := "../../sample/BingWallpaper-2015-11-07.jpg"
 663
 664         fileInfo, err := os.Stat(fileName)
 665         dataSize := fileInfo.Size()
 666         c.Assert(err, IsNil)
 667
 668         options := []oss.Option{oss.Meta("my", "myprop")}
 669         var cryptoContext PartCryptoContext
 670         cryptoContext.DataSize = dataSize
 671         cryptoContext.PartSize = -1
 672         _, err = bucket.InitiateMultipartUpload(objectName, nil, options...)
 673         c.Assert(err, NotNil)
 674
 675         _, err = bucket.InitiateMultipartUpload(objectName, &cryptoContext, options...)
 676         c.Assert(err, NotNil)
 677
 678         cryptoContext.PartSize = (dataSize / 16 / 3) * 16
 679         imur, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext, options...)
 680         c.Assert(err, IsNil)
 681
 682         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
 683         c.Assert(err, IsNil)
 684
 685         bakCC := cryptoContext.ContentCipher
 686         cryptoContext.ContentCipher = nil
 687
 688         i := 0
 689         // upload excepted the last part
 690         for ; i < len(chunks); i++ {
 691                 _, err = bucket.UploadPartFromFile(imur, fileName, chunks[i].Offset, chunks[i].Size, (int)(chunks[i].Number), cryptoContext)
 692                 c.Assert(err, NotNil)
 693
 694         }
 695
 696         i = 0
 697         cryptoContext.ContentCipher = bakCC
 698         cryptoContext.PartSize -= 1
 699         for ; i < len(chunks); i++ {
 700                 _, err = bucket.UploadPartFromFile(imur, fileName, chunks[i].Offset, chunks[i].Size, (int)(chunks[i].Number), cryptoContext)
 701                 c.Assert(err, NotNil)
 702         }
 703
 704         ForceDeleteBucket(client, bucketName, c)
 705 }
 706
 707 func (s *OssCryptoBucketSuite) TestMultipartUploadPartError(c *C) {
 708         // create a bucket with default proprety
 709         client, err := oss.New(endpoint, accessID, accessKey)
 710         c.Assert(err, IsNil)
 711
 712         bucketName := bucketNamePrefix + RandLowStr(6)
 713         err = client.CreateBucket(bucketName)
 714         c.Assert(err, IsNil)
 715
 716         // crypto bucket
 717         masterRsaCipher, _ := CreateMasterRsa(matDesc, rsaPublicKey, rsaPrivateKey)
 718         contentProvider := CreateAesCtrCipher(masterRsaCipher)
 719         bucket, err := GetCryptoBucket(client, bucketName, contentProvider)
 720
 721         objectName := objectNamePrefix + RandStr(8)
 722         fileName := "../../sample/BingWallpaper-2015-11-07.jpg"
 723
 724         fileInfo, err := os.Stat(fileName)
 725         dataSize := fileInfo.Size()
 726         c.Assert(err, IsNil)
 727
 728         options := []oss.Option{oss.Meta("my", "myprop")}
 729         var cryptoContext PartCryptoContext
 730         cryptoContext.DataSize = dataSize
 731         cryptoContext.PartSize = (dataSize / 16 / 3) * 16
 732         imur, err := bucket.InitiateMultipartUpload(objectName, &cryptoContext, options...)
 733         c.Assert(err, IsNil)
 734
 735         chunks, err := oss.SplitFileByPartSize(fileName, cryptoContext.PartSize)
 736         c.Assert(err, IsNil)
 737
 738         bakCC := cryptoContext.ContentCipher
 739         cryptoContext.ContentCipher = nil
 740
 741         fd, err := os.Open(fileName)
 742         c.Assert(err, IsNil)
 743
 744         for _, chunk := range chunks {
 745                 fd.Seek(chunk.Offset, os.SEEK_SET)
 746                 _, err = bucket.UploadPart(imur, fd, chunk.Size, chunk.Number, cryptoContext)
 747                 c.Assert(err, NotNil)
 748         }
 749
 750         cryptoContext.ContentCipher = bakCC
 751         cryptoContext.PartSize -= 1
 752         for _, chunk := range chunks {
 753                 _, err = bucket.UploadPart(imur, fd, chunk.Size, chunk.Number, cryptoContext)
 754                 c.Assert(err, NotNil)
 755         }
 756
 757         ForceDeleteBucket(client, bucketName, c)
 758 }