public async Task CloudFileWriteRangeAsync()
{
byte[] buffer = GetRandomBuffer(4 * 1024 * 1024);
#if NETCORE
MD5 md5 = MD5.Create();
string contentMD5 = Convert.ToBase64String(md5.ComputeHash(buffer));
#else
CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
hasher.Append(buffer.AsBuffer());
string contentMD5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset());
#endif
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
await file.CreateAsync(4 * 1024 * 1024);
using (MemoryStream memoryStream = new MemoryStream())
{
await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>(
async() => await file.WriteRangeAsync(memoryStream, 0, null),
"Zero-length WriteRange should fail");
}
using (MemoryStream resultingData = new MemoryStream())
{
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await file.WriteRangeAsync(memoryStream, 512, null, null, null, opContext),
opContext,
"Writing out-of-range ranges should fail",
HttpStatusCode.RequestedRangeNotSatisfiable,
"InvalidRange");
memoryStream.Seek(0, SeekOrigin.Begin);
await file.WriteRangeAsync(memoryStream, 0, contentMD5);
resultingData.Write(buffer, 0, buffer.Length);
int offset = buffer.Length - 1024;
memoryStream.Seek(offset, SeekOrigin.Begin);
await TestHelper.ExpectedExceptionAsync(
async() => await file.WriteRangeAsync(memoryStream, 0, contentMD5, null, null, opContext),
opContext,
"Invalid MD5 should fail with mismatch",
HttpStatusCode.BadRequest,
"Md5Mismatch");
memoryStream.Seek(offset, SeekOrigin.Begin);
await file.WriteRangeAsync(memoryStream, 0, null);
resultingData.Seek(0, SeekOrigin.Begin);
resultingData.Write(buffer, offset, buffer.Length - offset);
offset = buffer.Length - 2048;
memoryStream.Seek(offset, SeekOrigin.Begin);
await file.WriteRangeAsync(memoryStream, 1024, null);
resultingData.Seek(1024, SeekOrigin.Begin);
resultingData.Write(buffer, offset, buffer.Length - offset);
}
using (MemoryStream fileData = new MemoryStream())
{
await file.DownloadToStreamAsync(fileData);
Assert.AreEqual(resultingData.Length, fileData.Length);
Assert.IsTrue(fileData.ToArray().SequenceEqual(resultingData.ToArray()));
}
}
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public async Task CloudFileSetPropertiesAsync()
{
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
await file.CreateAsync(1024);
string eTag = file.Properties.ETag;
DateTimeOffset lastModified = file.Properties.LastModified.Value;
await Task.Delay(1000);
file.Properties.CacheControl = "no-transform";
file.Properties.ContentEncoding = "gzip";
file.Properties.ContentLanguage = "tr,en";
file.Properties.ContentMD5 = "MDAwMDAwMDA=";
file.Properties.ContentType = "text/html";
await file.SetPropertiesAsync();
Assert.IsTrue(file.Properties.LastModified > lastModified);
Assert.AreNotEqual(eTag, file.Properties.ETag);
CloudFile file2 = share.GetRootDirectoryReference().GetFileReference("file1");
await file2.FetchAttributesAsync();
Assert.AreEqual("no-transform", file2.Properties.CacheControl);
Assert.AreEqual("gzip", file2.Properties.ContentEncoding);
Assert.AreEqual("tr,en", file2.Properties.ContentLanguage);
Assert.AreEqual("MDAwMDAwMDA=", file2.Properties.ContentMD5);
Assert.AreEqual("text/html", file2.Properties.ContentType);
CloudFile file3 = share.GetRootDirectoryReference().GetFileReference("file1");
using (MemoryStream stream = new MemoryStream())
{
FileRequestOptions options = new FileRequestOptions()
{
DisableContentMD5Validation = true,
};
await file3.DownloadToStreamAsync(stream, null, options, null);
}
AssertAreEqual(file2.Properties, file3.Properties);
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
IEnumerable <IListFileItem> results = await ListFilesAndDirectoriesAsync(rootDirectory, null, null, null, null);
CloudFile file4 = (CloudFile)results.First();
Assert.AreEqual(file2.Properties.Length, file4.Properties.Length);
CloudFile file5 = share.GetRootDirectoryReference().GetFileReference("file1");
Assert.IsNull(file5.Properties.ContentMD5);
byte[] target = new byte[4];
await file5.DownloadRangeToByteArrayAsync(target, 0, 0, 4);
Assert.AreEqual("MDAwMDAwMDA=", file5.Properties.ContentMD5);
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public async Task CloudFileWriteRangeAsync()
{
byte[] buffer = GetRandomBuffer(4 * 1024 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
await file.CreateAsync(4 * 1024 * 1024);
using (MemoryStream memoryStream = new MemoryStream())
{
await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>(
async() => await file.WriteRangeAsync(memoryStream, 0, null),
"Zero-length WriteRange should fail");
memoryStream.SetLength(4 * 1024 * 1024 + 1);
await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>(
async() => await file.WriteRangeAsync(memoryStream, 0, null),
">4MB WriteRange should fail");
}
using (MemoryStream resultingData = new MemoryStream())
{
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await file.WriteRangeAsync(memoryStream, 512, null, null, null, opContext),
opContext,
"Writing out-of-range ranges should fail",
HttpStatusCode.RequestedRangeNotSatisfiable,
"InvalidFileRange");
memoryStream.Seek(0, SeekOrigin.Begin);
await file.WriteRangeAsync(memoryStream, 0, null);
resultingData.Write(buffer, 0, buffer.Length);
int offset = buffer.Length - 1024;
memoryStream.Seek(offset, SeekOrigin.Begin);
await file.WriteRangeAsync(memoryStream, 0, null);
resultingData.Seek(0, SeekOrigin.Begin);
resultingData.Write(buffer, offset, buffer.Length - offset);
offset = buffer.Length - 2048;
memoryStream.Seek(offset, SeekOrigin.Begin);
await file.WriteRangeAsync(memoryStream, 1024, null);
resultingData.Seek(1024, SeekOrigin.Begin);
resultingData.Write(buffer, offset, buffer.Length - offset);
}
using (MemoryStream fileData = new MemoryStream())
{
await file.DownloadToStreamAsync(fileData);
Assert.AreEqual(resultingData.Length, fileData.Length);
Assert.IsTrue(fileData.ToArray().SequenceEqual(resultingData.ToArray()));
}
}
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public async Task CloudFileListRangesAsync()
{
byte[] buffer = GetRandomBuffer(1024);
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
await file.CreateAsync(4 * 1024);
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
await file.WriteRangeAsync(memoryStream, 512, null);
}
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
await file.WriteRangeAsync(memoryStream, 3 * 1024, null);
}
await file.ClearRangeAsync(1024, 1024);
await file.ClearRangeAsync(0, 512);
IEnumerable <FileRange> fileRanges = await file.ListRangesAsync();
List <string> expectedFileRanges = new List <string>()
{
new FileRange(512, 1023).ToString(),
new FileRange(3 * 1024, 4 * 1024 - 1).ToString(),
};
foreach (FileRange fileRange in fileRanges)
{
Assert.IsTrue(expectedFileRanges.Remove(fileRange.ToString()));
}
Assert.AreEqual(0, expectedFileRanges.Count);
fileRanges = await file.ListRangesAsync(1024, 1024, null, null, null);
Assert.AreEqual(0, fileRanges.Count());
fileRanges = await file.ListRangesAsync(512, 3 * 1024, null, null, null);
expectedFileRanges = new List <string>()
{
new FileRange(512, 1023).ToString(),
new FileRange(3 * 1024, 7 * 512 - 1).ToString(),
};
foreach (FileRange fileRange in fileRanges)
{
Assert.IsTrue(expectedFileRanges.Remove(fileRange.ToString()));
}
Assert.AreEqual(0, expectedFileRanges.Count);
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await file.ListRangesAsync(1024, null, null, null, opContext),
opContext,
"List Ranges with an offset but no count should fail",
HttpStatusCode.Unused);
Assert.IsInstanceOfType(opContext.LastResult.Exception.InnerException, typeof(ArgumentNullException));
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public async Task CloudFileShareTryGetValuePermissions()
{
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
FileSharePermissions permissions = await share.GetPermissionsAsync();
Assert.AreEqual(0, permissions.SharedAccessPolicies.Count);
// We do not have precision at milliseconds level. Hence, we need
// to recreate the start DateTime to be able to compare it later.
DateTime start = DateTime.UtcNow;
start = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, start.Second, DateTimeKind.Utc);
DateTime expiry = start.AddMinutes(30);
KeyValuePair <String, SharedAccessFilePolicy> sharedAccessPolicy = new KeyValuePair <string, SharedAccessFilePolicy>("key1", new SharedAccessFilePolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = SharedAccessFilePermissions.List,
});
DateTime start2 = DateTime.UtcNow;
start2 = new DateTime(start2.Year, start2.Month, start2.Day, start2.Hour, start2.Minute, start2.Second, DateTimeKind.Utc);
DateTime expiry2 = start2.AddMinutes(30);
KeyValuePair <String, SharedAccessFilePolicy> sharedAccessPolicy2 = new KeyValuePair <string, SharedAccessFilePolicy>("key2", new SharedAccessFilePolicy()
{
SharedAccessStartTime = start2,
SharedAccessExpiryTime = expiry2,
Permissions = SharedAccessFilePermissions.List,
});
permissions.SharedAccessPolicies.Add(sharedAccessPolicy);
permissions.SharedAccessPolicies.Add(sharedAccessPolicy2);
await share.SetPermissionsAsync(permissions);
await Task.Delay(3 * 1000);
Assert.AreEqual(2, permissions.SharedAccessPolicies.Count);
permissions = await share.GetPermissionsAsync();
SharedAccessFilePolicy retrPolicy;
permissions.SharedAccessPolicies.TryGetValue("key1", out retrPolicy);
Assert.AreEqual(sharedAccessPolicy.Value.Permissions, retrPolicy.Permissions);
Assert.AreEqual(sharedAccessPolicy.Value.SharedAccessStartTime, retrPolicy.SharedAccessStartTime);
Assert.AreEqual(sharedAccessPolicy.Value.SharedAccessExpiryTime, retrPolicy.SharedAccessExpiryTime);
SharedAccessFilePolicy retrPolicy2;
permissions.SharedAccessPolicies.TryGetValue("key2", out retrPolicy2);
Assert.AreEqual(sharedAccessPolicy2.Value.Permissions, retrPolicy2.Permissions);
Assert.AreEqual(sharedAccessPolicy2.Value.SharedAccessStartTime, retrPolicy2.SharedAccessStartTime);
Assert.AreEqual(sharedAccessPolicy2.Value.SharedAccessExpiryTime, retrPolicy2.SharedAccessExpiryTime);
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public async Task FileWriteStreamFlushTestAsync()
{
byte[] buffer = GetRandomBuffer(512);
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
file.StreamWriteSizeInBytes = 1024;
using (MemoryStream wholeFile = new MemoryStream())
{
FileRequestOptions options = new FileRequestOptions()
{
StoreFileContentMD5 = true
};
OperationContext opContext = new OperationContext();
using (ICloudFileStream fileStream = await file.OpenWriteAsync(4 * 512, null, options, opContext))
{
for (int i = 0; i < 3; i++)
{
await fileStream.WriteAsync(buffer.AsBuffer());
await wholeFile.WriteAsync(buffer, 0, buffer.Length);
}
Assert.AreEqual(2, opContext.RequestResults.Count);
await fileStream.FlushAsync();
Assert.AreEqual(3, opContext.RequestResults.Count);
await fileStream.FlushAsync();
Assert.AreEqual(3, opContext.RequestResults.Count);
await fileStream.WriteAsync(buffer.AsBuffer());
await wholeFile.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(3, opContext.RequestResults.Count);
await fileStream.CommitAsync();
Assert.AreEqual(5, opContext.RequestResults.Count);
}
Assert.AreEqual(5, opContext.RequestResults.Count);
using (MemoryOutputStream downloadedFile = new MemoryOutputStream())
{
await file.DownloadToStreamAsync(downloadedFile);
TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile.UnderlyingStream);
}
}
}
finally
{
share.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task CloudFileSASSharedProtocolsQueryParamAsync()
{
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file;
SharedAccessFilePolicy policy = new SharedAccessFilePolicy()
{
Permissions = SharedAccessFilePermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudFile fileWithKey = share.GetRootDirectoryReference().GetFileReference("filefile");
byte[] data = new byte[] { 0x1, 0x2, 0x3, 0x4 };
byte[] target = new byte[4];
await fileWithKey.UploadFromByteArrayAsync(data, 0, 4);
foreach (SharedAccessProtocol?protocol in new SharedAccessProtocol?[] { null, SharedAccessProtocol.HttpsOrHttp, SharedAccessProtocol.HttpsOnly })
{
string fileToken = fileWithKey.GetSharedAccessSignature(policy, null, null, protocol, null);
StorageCredentials fileSAS = new StorageCredentials(fileToken);
Uri fileSASUri = new Uri(fileWithKey.Uri + fileSAS.SASToken);
StorageUri fileSASStorageUri = new StorageUri(new Uri(fileWithKey.StorageUri.PrimaryUri + fileSAS.SASToken), new Uri(fileWithKey.StorageUri.SecondaryUri + fileSAS.SASToken));
int httpPort = fileSASUri.Port;
int securePort = 443;
if (!string.IsNullOrEmpty(TestBase.TargetTenantConfig.FileSecurePortOverride))
{
securePort = Int32.Parse(TestBase.TargetTenantConfig.FileSecurePortOverride);
}
var schemesAndPorts = new[] {
new { scheme = "HTTP", port = httpPort },
new { scheme = "HTTPS", port = securePort }
};
foreach (var item in schemesAndPorts)
{
fileSASUri = TransformSchemeAndPort(fileSASUri, item.scheme, item.port);
fileSASStorageUri = new StorageUri(TransformSchemeAndPort(fileSASStorageUri.PrimaryUri, item.scheme, item.port), TransformSchemeAndPort(fileSASStorageUri.SecondaryUri, item.scheme, item.port));
if (protocol.HasValue && protocol == SharedAccessProtocol.HttpsOnly && string.CompareOrdinal(item.scheme, "HTTP") == 0)
{
file = new CloudFile(fileSASUri);
OperationContext context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await file.FetchAttributesAsync(null /* accessCondition */, null /* options */, context),
context,
"Access a file using SAS with a shared protocols that does not match",
HttpStatusCode.Unused,
"");
file = new CloudFile(fileSASStorageUri, null);
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await file.FetchAttributesAsync(null /* accessCondition */, null /* options */, context),
context,
"Access a file using SAS with a shared protocols that does not match",
HttpStatusCode.Unused,
"");
}
else
{
file = new CloudFile(fileSASUri);
await file.DownloadRangeToByteArrayAsync(target, 0, 0, 4, null, null, null);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(data[i], target[i]);
}
file = new CloudFile(fileSASStorageUri, null);
await file.DownloadRangeToByteArrayAsync(target, 0, 0, 4, null, null, null);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(data[i], target[i]);
}
}
}
}
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public async Task FileReadLockToETagTestAsync()
{
byte[] outBuffer = new byte[1 * 1024 * 1024];
byte[] buffer = GetRandomBuffer(2 * outBuffer.Length);
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
file.StreamMinimumReadSizeInBytes = outBuffer.Length;
using (MemoryStream wholeFile = new MemoryStream(buffer))
{
await file.UploadFromStreamAsync(wholeFile.AsInputStream());
}
OperationContext opContext = new OperationContext();
using (IRandomAccessStreamWithContentType fileStream = await file.OpenReadAsync(null, null, opContext))
{
Stream fileStreamForRead = fileStream.AsStreamForRead();
await fileStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length);
await file.SetMetadataAsync();
await TestHelper.ExpectedExceptionAsync(
async() => await fileStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length),
opContext,
"File read stream should fail if file is modified during read",
HttpStatusCode.PreconditionFailed);
}
opContext = new OperationContext();
using (IRandomAccessStreamWithContentType fileStream = await file.OpenReadAsync(null, null, opContext))
{
Stream fileStreamForRead = fileStream.AsStreamForRead();
long length = fileStreamForRead.Length;
await file.SetMetadataAsync();
await TestHelper.ExpectedExceptionAsync(
async() => await fileStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length),
opContext,
"File read stream should fail if file is modified during read",
HttpStatusCode.PreconditionFailed);
}
/*
* opContext = new OperationContext();
* AccessCondition accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(DateTimeOffset.Now.Subtract(TimeSpan.FromHours(1)));
* await file.SetMetadataAsync();
* await TestHelper.ExpectedExceptionAsync(
* async () => await file.OpenReadAsync(accessCondition, null, opContext),
* opContext,
* "File read stream should fail if file is modified during read",
* HttpStatusCode.PreconditionFailed);
*/
}
finally
{
share.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task CloudFileClientMaximumExecutionTimeoutShouldNotBeHonoredForStreamsAsync()
{
CloudFileClient fileClient = GenerateCloudFileClient();
CloudFileShare share = fileClient.GetShareReference(Guid.NewGuid().ToString("N"));
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
byte[] buffer = FileTestBase.GetRandomBuffer(1024 * 1024);
try
{
await share.CreateAsync();
fileClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(30);
CloudFile file = rootDirectory.GetFileReference("file");
file.StreamMinimumReadSizeInBytes = 1024 * 1024;
using (ICloudFileStream fileStream = await file.OpenWriteAsync(8 * 1024 * 1024))
{
Stream fos = fileStream.AsStreamForWrite();
DateTime start = DateTime.Now;
for (int i = 0; i < 7; i++)
{
await fos.WriteAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last write
int msRemaining = (int)(fileClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
await fos.WriteAsync(buffer, 0, buffer.Length);
await fileStream.CommitAsync();
}
using (IRandomAccessStreamWithContentType fileStream = await file.OpenReadAsync())
{
Stream fis = fileStream.AsStreamForRead();
DateTime start = DateTime.Now;
int total = 0;
while (total < 7 * 1024 * 1024)
{
total += await fis.ReadAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last read
int msRemaining = (int)(fileClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
while (true)
{
int count = await fis.ReadAsync(buffer, 0, buffer.Length);
total += count;
if (count == 0)
{
break;
}
}
}
}
finally
{
fileClient.DefaultRequestOptions.MaximumExecutionTime = null;
share.DeleteIfExistsAsync().AsTask().Wait();
}
}
private static async Task CloudFileCopyAsync(bool sourceIsSas, bool destinationIsSas)
{
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
// Create Source on server
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
string data = "String data";
await UploadTextAsync(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
await source.SetMetadataAsync();
// Create Destination on server
CloudFile destination = share.GetRootDirectoryReference().GetFileReference("destination");
await destination.CreateAsync(1);
CloudFile copySource = source;
CloudFile copyDestination = destination;
if (sourceIsSas)
{
// Source SAS must have read permissions
SharedAccessFilePermissions permissions = SharedAccessFilePermissions.Read;
SharedAccessFilePolicy policy = new SharedAccessFilePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = permissions,
};
string sasToken = source.GetSharedAccessSignature(policy);
// Get source
StorageCredentials credentials = new StorageCredentials(sasToken);
copySource = new CloudFile(credentials.TransformUri(source.Uri));
}
if (destinationIsSas)
{
Assert.IsTrue(sourceIsSas);
// Destination SAS must have write permissions
SharedAccessFilePermissions permissions = SharedAccessFilePermissions.Write;
SharedAccessFilePolicy policy = new SharedAccessFilePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = permissions,
};
string sasToken = destination.GetSharedAccessSignature(policy);
// Get destination
StorageCredentials credentials = new StorageCredentials(sasToken);
copyDestination = new CloudFile(credentials.TransformUri(destination.Uri));
}
// Start copy and wait for completion
string copyId = await copyDestination.StartCopyAsync(TestHelper.Defiddler(copySource));
await WaitForCopyAsync(destination);
// Check original file references for equality
Assert.AreEqual(CopyStatus.Success, destination.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, destination.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, destination.CopyState.TotalBytes);
Assert.AreEqual(data.Length, destination.CopyState.BytesCopied);
Assert.AreEqual(copyId, destination.CopyState.CopyId);
Assert.IsTrue(destination.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
if (!destinationIsSas)
{
// Abort Copy is not supported for SAS destination
OperationContext context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await copyDestination.AbortCopyAsync(copyId, null, null, context),
context,
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
}
await source.FetchAttributesAsync();
Assert.IsNotNull(destination.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, destination.Properties.ETag);
Assert.IsTrue(destination.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = await DownloadTextAsync(destination, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of file not equal.");
await destination.FetchAttributesAsync();
FileProperties prop1 = destination.Properties;
FileProperties prop2 = source.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage);
Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5);
Assert.AreEqual(prop1.ContentType, prop2.ContentType);
Assert.AreEqual("value", destination.Metadata["Test"], false, "Copied metadata not same");
await destination.DeleteAsync();
await source.DeleteAsync();
}
finally
{
share.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task FileDisableContentMD5ValidationTestAsync()
{
byte[] buffer = new byte[1024];
Random random = new Random();
random.NextBytes(buffer);
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
DisableContentMD5Validation = true,
StoreFileContentMD5 = true,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
DisableContentMD5Validation = false,
StoreFileContentMD5 = true,
};
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file2");
using (Stream stream = new MemoryStream(buffer))
{
await file.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
using (Stream stream = new MemoryStream())
{
await file.DownloadToStreamAsync(stream, null, optionsWithMD5, null);
await file.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (var fileStream = await file.OpenReadAsync(null, optionsWithMD5, null))
{
Stream fileStreamForRead = fileStream;
int read;
do
{
read = await fileStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
using (var fileStream = await file.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream fileStreamForRead = fileStream;
int read;
do
{
read = await fileStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
file.Properties.ContentMD5 = "MDAwMDAwMDA=";
await file.SetPropertiesAsync();
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await file.DownloadToStreamAsync(stream, null, optionsWithMD5, opContext),
opContext,
"Downloading a file with invalid MD5 should fail",
HttpStatusCode.OK);
await file.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (var fileStream = await file.OpenReadAsync(null, optionsWithMD5, null))
{
Stream fileStreamForRead = fileStream;
TestHelper.ExpectedException <IOException>(
() =>
{
int read;
do
{
read = fileStreamForRead.Read(buffer, 0, buffer.Length);
}while (read > 0);
},
"Downloading a file with invalid MD5 should fail");
}
using (var fileStream = await file.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream fileStreamForRead = fileStream;
int read;
do
{
read = await fileStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
}
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
