github.com/aliyun/aliyun-oss-go-sdk@v3.0.2+incompatible/oss/crypto/crypto_multipart_test.go (about)

     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  }