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 Range()
{
await ObjectClient.PutObjectStringAsync(BucketName, nameof(Range), "123456789012345678901234567890123456789012345678901234567890").ConfigureAwait(false);
GetObjectResponse resp = await ObjectClient.GetObjectAsync(BucketName, nameof(Range), request => request.Range.Add(0, 10)).ConfigureAwait(false);
Assert.Equal(206, resp.StatusCode);
Assert.Equal(11, resp.ContentLength);
}
public async Task PutObjectValidCharacters(string name)
{
PutObjectResponse putResp = await ObjectClient.PutObjectStringAsync(BucketName, name, string.Empty).ConfigureAwait(false);
Assert.True(putResp.IsSuccess);
GetObjectResponse getResp = await ObjectClient.GetObjectAsync(BucketName, name).ConfigureAwait(false);
Assert.True(getResp.IsSuccess);
}
public async Task PutObjectRequestPayer()
{
PutObjectResponse putResp = await ObjectClient.PutObjectAsync(BucketName, nameof(PutObjectRequestPayer), null, req => req.RequestPayer = Payer.Requester).ConfigureAwait(false);
Assert.True(putResp.RequestCharged);
GetObjectResponse getResp = await ObjectClient.GetObjectAsync(BucketName, nameof(PutObjectRequestPayer), req => req.RequestPayer = Payer.Requester).ConfigureAwait(false);
Assert.True(getResp.RequestCharged);
}
public async Task NameTests(string name)
{
await ObjectClient.PutObjectStringAsync(BucketName, name, name).ConfigureAwait(false);
GetObjectResponse dlResp = await ObjectClient.GetObjectAsync(BucketName, name).ConfigureAwait(false);
Assert.Equal("binary/octet-stream", dlResp.ContentType);
Assert.Equal(name.Length, dlResp.ContentLength);
Assert.Equal(name, Encoding.UTF8.GetString(await dlResp.Content.AsDataAsync().ConfigureAwait(false)));
}
public async Task GetObjectContentRange()
{
await UploadAsync(nameof(GetObjectContentRange)).ConfigureAwait(false);
GetObjectResponse getResp = await ObjectClient.GetObjectAsync(BucketName, nameof(GetObjectContentRange), req => req.Range.Add(0, 2)).ConfigureAwait(false);
Assert.Equal(206, getResp.StatusCode);
Assert.Equal(3, getResp.ContentLength);
Assert.Equal("bytes", getResp.AcceptRanges);
Assert.Equal("bytes 0-2/4", getResp.ContentRange);
Assert.Equal("tes", await getResp.Content.AsStringAsync().ConfigureAwait(false));
}
protected async Task <GetObjectResponse> AssertAsync(string bucketName, string objectKey, Action <GetObjectRequest>?config = null, bool assumeSuccess = true)
{
GetObjectResponse resp = await ObjectClient.GetObjectAsync(bucketName, objectKey, config).ConfigureAwait(false);
if (assumeSuccess)
{
Assert.True(resp.IsSuccess);
Assert.Equal("test", await resp.Content !.AsStringAsync().ConfigureAwait(false));
}
return(resp);
}
public async Task MultipartUpload()
{
string objectKey = nameof(MultipartUpload);
CreateMultipartUploadResponse initResp = await MultipartClient.CreateMultipartUploadAsync(BucketName, objectKey).ConfigureAwait(false);
Assert.True(initResp.IsSuccess);
Assert.Equal(BucketName, initResp.Bucket);
Assert.Equal(objectKey, initResp.ObjectKey);
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 MultipartClient.UploadPartAsync(BucketName, objectKey, 1, initResp.UploadId, new MemoryStream(parts[0])).ConfigureAwait(false);
Assert.True(uploadResp1.IsSuccess);
Assert.NotNull(uploadResp1.ETag);
UploadPartResponse uploadResp2 = await MultipartClient.UploadPartAsync(BucketName, objectKey, 2, initResp.UploadId, new MemoryStream(parts[1])).ConfigureAwait(false);
Assert.True(uploadResp2.IsSuccess);
Assert.NotNull(uploadResp2.ETag);
CompleteMultipartUploadResponse completeResp = await MultipartClient.CompleteMultipartUploadAsync(BucketName, objectKey, initResp.UploadId, new[] { uploadResp1, uploadResp2 }).ConfigureAwait(false);
Assert.True(completeResp.IsSuccess);
Assert.NotNull(uploadResp2.ETag);
GetObjectResponse getResp = await ObjectClient.GetObjectAsync(BucketName, objectKey).ConfigureAwait(false);
//Provoke an 'InvalidArgument' error
GetObjectResponse gResp1 = await ObjectClient.GetObjectAsync(BucketName, nameof(MultipartUpload), req => req.PartNumber = 0).ConfigureAwait(false);
Assert.False(gResp1.IsSuccess);
Assert.IsType <InvalidArgumentError>(gResp1.Error);
GetObjectResponse gResp2 = await ObjectClient.GetObjectAsync(BucketName, nameof(MultipartUpload), req => req.PartNumber = 1).ConfigureAwait(false);
Assert.True(gResp2.IsSuccess);
Assert.Equal(file.Length / 2, (await gResp2.Content.AsDataAsync().ConfigureAwait(false)).Length);
Assert.Equal(file, await getResp.Content.AsDataAsync().ConfigureAwait(false));
}
public async Task MultipartViaClient()
{
byte[] data = new byte[10 * 1024 * 1024]; //10 Mb
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 255);
}
using (MemoryStream ms = new MemoryStream(data))
{
MultipartUploadStatus resp = await MultipartClient.MultipartUploadAsync(BucketName, nameof(MultipartViaClient), ms, 5 * 1024 * 1024).ConfigureAwait(false);
Assert.Equal(MultipartUploadStatus.Ok, resp);
}
GetObjectResponse getResp = await ObjectClient.GetObjectAsync(BucketName, nameof(MultipartViaClient)).ConfigureAwait(false);
Assert.True(getResp.IsSuccess);
using (MemoryStream ms = new MemoryStream())
{
await getResp.Content.CopyToAsync(ms).ConfigureAwait(false);
Assert.Equal(data, ms.ToArray());
}
//Try multipart downloading it
using (MemoryStream ms = new MemoryStream())
{
await MultipartClient.MultipartDownloadAsync(BucketName, nameof(MultipartViaClient), ms).ConfigureAwait(false);
Assert.Equal(data, ms.ToArray());
}
HeadObjectResponse headResp = await ObjectClient.HeadObjectAsync(BucketName, nameof(MultipartViaClient), req => req.PartNumber = 1).ConfigureAwait(false);
Assert.Equal(2, headResp.NumberOfParts);
}
public async Task ResponseHeaders()
{
//Upload a file for tests
await UploadAsync(nameof(ResponseHeaders)).ConfigureAwait(false);
GetObjectResponse response = await ObjectClient.GetObjectAsync(BucketName, nameof(ResponseHeaders), request =>
{
request.ResponseCacheControl.Set(CacheControlType.MaxAge, 42);
request.ResponseContentDisposition.Set(ContentDispositionType.Attachment, "filename.txt");
request.ResponseContentEncoding.Add(ContentEncodingType.Gzip);
request.ResponseContentLanguage.Add("da-DK");
request.ResponseContentType.Set("text/html", "utf-8");
request.ResponseExpires = DateTimeOffset.UtcNow;
}).ConfigureAwait(false);
Assert.Equal("max-age=42", response.CacheControl);
Assert.Equal("attachment; filename*=\"filename.txt\"", response.ContentDisposition);
Assert.Equal("gzip", response.ContentEncoding);
Assert.Equal("da-DK", response.ContentLanguage);
Assert.Equal("text/html; charset=utf-8", response.ContentType);
Assert.Equal(DateTime.UtcNow, response.Expires.Value.DateTime, TimeSpan.FromSeconds(5));
}
public async Task MultipartFluid()
{
byte[] data = new byte[10 * 1024 * 1024]; //10 Mb
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 255);
}
MultipartUploadStatus resp = await Transfer.UploadData(BucketName, nameof(MultipartFluid), data)
.ExecuteMultipartAsync()
.ConfigureAwait(false);
Assert.Equal(MultipartUploadStatus.Ok, resp);
GetObjectResponse getResp = await ObjectClient.GetObjectAsync(BucketName, nameof(MultipartViaClient)).ConfigureAwait(false);
Assert.True(getResp.IsSuccess);
using (MemoryStream ms = new MemoryStream())
{
await getResp.Content.CopyToAsync(ms).ConfigureAwait(false);
Assert.Equal(data, ms.ToArray());
}
//TODO: Need Download Transfer support first
//Try multipart downloading it
//using (MemoryStream ms = new MemoryStream())
//{
// await ObjectClient.MultipartDownloadAsync(BucketName, nameof(MultipartViaClient), ms).ConfigureAwait(false);
// Assert.Equal(data, ms.ToArray());
//}
HeadObjectResponse headResp = await ObjectClient.HeadObjectAsync(BucketName, nameof(MultipartViaClient), req => req.PartNumber = 1).ConfigureAwait(false);
Assert.Equal(2, headResp.NumberOfParts);
}
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));
}
