public async Task ListObjects()
{
await CreateTempBucketAsync(async bucket =>
{
//Create 3 objects in bucket, including an incomplete multipart upload
await UploadAsync(bucket, "resource1").ConfigureAwait(false);
await UploadAsync(bucket, "resource2").ConfigureAwait(false);
InitiateMultipartUploadResponse initResp = await ObjectClient.InitiateMultipartUploadAsync(bucket, "multipart").ConfigureAwait(false);
//List the objects
List <S3Object> list = await BucketClient.GetBucketRecursiveAsync(bucket, true).ToListAsync().ConfigureAwait(false);
//Only 2 objects should be present, as one of them is only initiated
Assert.Equal(2, list.Count);
Assert.Equal("resource1", list[0].Name);
Assert.Equal("resource2", list[1].Name);
//List multipart transfers
List <S3Upload> uploads = await BucketClient.ListAllMultipartUploadsAsync(bucket).ToListAsync().ConfigureAwait(false);
S3Upload upload = Assert.Single(uploads);
Assert.Equal("multipart", upload.Name);
}).ConfigureAwait(false);
}
public async Task ListIncompleteParts()
{
await CreateTempBucketAsync(async bucket =>
{
InitiateMultipartUploadResponse initResp = await ObjectClient.InitiateMultipartUploadAsync(bucket, nameof(ListIncompleteParts)).ConfigureAwait(false);
byte[] file = new byte[5 * 1024];
using (MemoryStream ms = new MemoryStream(file))
await ObjectClient.UploadPartAsync(bucket, nameof(ListIncompleteParts), 1, initResp.UploadId, ms).ConfigureAwait(false);
ListMultipartUploadsResponse listResp = await BucketClient.ListMultipartUploadsAsync(bucket).ConfigureAwait(false);
Assert.Equal(bucket, listResp.Bucket);
Assert.Equal("ListIncompleteParts", listResp.NextKeyMarker);
Assert.NotEmpty(listResp.NextUploadIdMarker);
Assert.Equal(1000, listResp.MaxUploads);
Assert.False(listResp.IsTruncated);
S3Upload upload = Assert.Single(listResp.Uploads);
Assert.Equal(listResp.NextKeyMarker, upload.Name);
Assert.Equal(listResp.NextUploadIdMarker, upload.UploadId);
Assert.Equal(TestConstants.TestUsername, upload.Initiator.Name);
Assert.Equal(StorageClass.Standard, upload.StorageClass);
Assert.Equal(DateTime.UtcNow, upload.Initiated.DateTime, TimeSpan.FromSeconds(5));
}).ConfigureAwait(false);
}
public async Task TooSmallUpload()
{
string resourceName = nameof(TooSmallUpload);
InitiateMultipartUploadResponse initResp = await ObjectClient.InitiateMultipartUploadAsync(BucketName, resourceName).ConfigureAwait(false);
Assert.Equal(BucketName, initResp.Bucket);
Assert.Equal(resourceName, initResp.Key);
Assert.NotNull(initResp.UploadId);
//4 MB is below the 5 MB limit. See https://docs.aws.amazon.com/AmazonS3/latest/dev/qfacts.html
//Note that if there only is 1 part, then it is technically the last part, and can be of any size. That's why this test has 2 parts.
byte[] file = new byte[1024 * 1024 * 4];
byte[][] chunks = file.Chunk(file.Length / 2).Select(x => x.ToArray()).ToArray();
UploadPartResponse uploadResp1 = await ObjectClient.UploadPartAsync(BucketName, resourceName, 1, initResp.UploadId, new MemoryStream(chunks[0])).ConfigureAwait(false);
Assert.True(uploadResp1.IsSuccess);
Assert.NotNull(uploadResp1.ETag);
UploadPartResponse uploadResp2 = await ObjectClient.UploadPartAsync(BucketName, resourceName, 2, initResp.UploadId, new MemoryStream(chunks[1])).ConfigureAwait(false);
Assert.True(uploadResp2.IsSuccess);
Assert.NotNull(uploadResp2.ETag);
CompleteMultipartUploadResponse completeResp = await ObjectClient.CompleteMultipartUploadAsync(BucketName, resourceName, initResp.UploadId, new[] { uploadResp1, uploadResp2 }).ConfigureAwait(false);
Assert.False(completeResp.IsSuccess);
Assert.Equal(400, completeResp.StatusCode);
}
public async Task ManualSinglePartUpload()
{
string resourceName = nameof(ManualSinglePartUpload);
InitiateMultipartUploadResponse initResp = await ObjectClient.InitiateMultipartUploadAsync(BucketName, resourceName, request =>
{
request.SseAlgorithm = SseAlgorithm.Aes256;
request.StorageClass = StorageClass.StandardIa;
}).ConfigureAwait(false);
Assert.True(initResp.IsSuccess);
Assert.Equal(BucketName, initResp.Bucket);
Assert.Equal(resourceName, initResp.Key);
Assert.NotNull(initResp.UploadId);
byte[] file = new byte[1024 * 1024 * 5];
file[0] = (byte)'a';
UploadPartResponse uploadResp = await ObjectClient.UploadPartAsync(BucketName, resourceName, 1, initResp.UploadId, new MemoryStream(file)).ConfigureAwait(false);
Assert.True(uploadResp.IsSuccess);
Assert.NotNull(uploadResp.ETag);
Assert.Equal(SseAlgorithm.Aes256, uploadResp.SseAlgorithm);
Assert.Equal(StorageClass.StandardIa, uploadResp.StorageClass);
CompleteMultipartUploadResponse completeResp = await ObjectClient.CompleteMultipartUploadAsync(BucketName, resourceName, initResp.UploadId, new[] { uploadResp }).ConfigureAwait(false);
Assert.True(completeResp.IsSuccess);
Assert.NotNull(completeResp.ETag);
GetObjectResponse resp = await ObjectClient.GetObjectAsync(BucketName, resourceName).ConfigureAwait(false);
Assert.True(resp.IsSuccess);
Assert.Equal(file, await resp.Content.AsDataAsync().ConfigureAwait(false));
}
public async Task AbortIncompleteUpload()
{
string resourceName = nameof(AbortIncompleteUpload);
InitiateMultipartUploadResponse initResp = await ObjectClient.InitiateMultipartUploadAsync(BucketName, resourceName).ConfigureAwait(false);
Assert.Equal(BucketName, initResp.Bucket);
Assert.Equal(resourceName, initResp.Key);
Assert.NotNull(initResp.UploadId);
AbortMultipartUploadResponse abortResp = await ObjectClient.AbortMultipartUploadAsync(BucketName, resourceName, initResp.UploadId).ConfigureAwait(false);
Assert.True(abortResp.IsSuccess);
Assert.Equal(204, abortResp.StatusCode);
}
public async Task ManualMultiplePartUpload()
{
string resourceName = nameof(ManualMultiplePartUpload);
byte[] key = { 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8 };
byte[] keyMd5 = CryptoHelper.Md5Hash(key);
InitiateMultipartUploadResponse initResp = await ObjectClient.InitiateMultipartUploadAsync(BucketName, resourceName, request =>
{
request.SseCustomerAlgorithm = SseCustomerAlgorithm.Aes256;
request.SseCustomerKey = key;
request.SseCustomerKeyMd5 = keyMd5;
}).ConfigureAwait(false);
Assert.True(initResp.IsSuccess);
Assert.Equal(BucketName, initResp.Bucket);
Assert.Equal(resourceName, initResp.Key);
Assert.NotNull(initResp.UploadId);
byte[] file = new byte[1024 * 1024 * 10];
file[0] = (byte)'a';
file[file.Length - 1] = (byte)'b';
byte[][] parts = file.Chunk(file.Length / 2).Select(x => x.ToArray()).ToArray();
UploadPartResponse uploadResp1 = await ObjectClient.UploadPartAsync(BucketName, resourceName, 1, initResp.UploadId, new MemoryStream(parts[0]), request =>
{
request.SseCustomerAlgorithm = SseCustomerAlgorithm.Aes256;
request.SseCustomerKey = key;
request.SseCustomerKeyMd5 = keyMd5;
}).ConfigureAwait(false);
Assert.Equal(SseCustomerAlgorithm.Aes256, uploadResp1.SseCustomerAlgorithm);
Assert.Equal(keyMd5, uploadResp1.SseCustomerKeyMd5);
Assert.True(uploadResp1.IsSuccess);
Assert.NotNull(uploadResp1.ETag);
UploadPartResponse uploadResp2 = await ObjectClient.UploadPartAsync(BucketName, resourceName, 2, initResp.UploadId, new MemoryStream(parts[1]), request =>
{
request.SseCustomerAlgorithm = SseCustomerAlgorithm.Aes256;
request.SseCustomerKey = key;
request.SseCustomerKeyMd5 = keyMd5;
}).ConfigureAwait(false);
Assert.True(uploadResp2.IsSuccess);
Assert.NotNull(uploadResp2.ETag);
CompleteMultipartUploadResponse completeResp = await ObjectClient.CompleteMultipartUploadAsync(BucketName, resourceName, initResp.UploadId, new[] { uploadResp1, uploadResp2 }).ConfigureAwait(false);
Assert.True(completeResp.IsSuccess);
Assert.NotNull(uploadResp2.ETag);
GetObjectResponse getResp = await ObjectClient.GetObjectAsync(BucketName, resourceName, request =>
{
request.SseCustomerAlgorithm = SseCustomerAlgorithm.Aes256;
request.SseCustomerKey = key;
request.SseCustomerKeyMd5 = keyMd5;
}).ConfigureAwait(false);
//Provoke an 'InvalidArgument' error
GetObjectResponse gResp1 = await ObjectClient.GetObjectAsync(BucketName, nameof(ManualMultiplePartUpload), request =>
{
request.PartNumber = 0;
request.SseCustomerAlgorithm = SseCustomerAlgorithm.Aes256;
request.SseCustomerKey = key;
request.SseCustomerKeyMd5 = keyMd5;
}).ConfigureAwait(false);
Assert.False(gResp1.IsSuccess);
Assert.IsType <InvalidArgumentError>(gResp1.Error);
GetObjectResponse gResp2 = await ObjectClient.GetObjectAsync(BucketName, nameof(ManualMultiplePartUpload), request =>
{
request.PartNumber = 1;
request.SseCustomerAlgorithm = SseCustomerAlgorithm.Aes256;
request.SseCustomerKey = key;
request.SseCustomerKeyMd5 = keyMd5;
}).ConfigureAwait(false);
Assert.True(gResp2.IsSuccess);
Assert.Equal(file.Length / 2, gResp2.Content.AsStream().Length);
Assert.Equal(file, await getResp.Content.AsDataAsync().ConfigureAwait(false));
}
