public void MyTestInitialize()
{
if (TestBase.FileBufferManager != null)
{
TestBase.FileBufferManager.OutstandingBufferCount = 0;
}
this.share = GetRandomShareReference();
this.share.CreateIfNotExists();
CloudFileDirectory directory = share.GetRootDirectoryReference();
this.directory = directory.GetDirectoryReference("directory");
this.directory.Create();
this.file = this.directory.GetFileReference("file");
this.file.UploadText("test");
}
public static List <string> CreateFilesTask(CloudFileShare share, int count)
{
string name;
List <string> files = new List <string>();
List <Task> tasks = new List <Task>();
for (int i = 0; i < count; i++)
{
name = "ff" + Guid.NewGuid().ToString();
CloudFile file = share.GetRootDirectoryReference().GetFileReference(name);
tasks.Add(file.CreateAsync(0));
files.Add(name);
}
Task.WaitAll(tasks.ToArray());
return(files);
}
public async Task CloudFileShareUpdateSASTokenAsync()
{
// Create a policy with read/write access and get SAS.
SharedAccessFilePolicy policy = new SharedAccessFilePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = SharedAccessFilePermissions.Read | SharedAccessFilePermissions.Write,
};
string sasToken = this.testShare.GetSharedAccessSignature(policy);
//Thread.Sleep(35000);
CloudFile testFile = this.testShare.GetRootDirectoryReference().GetFileReference("file");
await UploadTextAsync(testFile, "file", Encoding.UTF8);
await TestAccess(sasToken, SharedAccessFilePermissions.Read | SharedAccessFilePermissions.Write, null, this.testShare, testFile);
StorageCredentials creds = new StorageCredentials(sasToken);
// Change the policy to only read and update SAS.
SharedAccessFilePolicy policy2 = new SharedAccessFilePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = SharedAccessFilePermissions.Read
};
string sasToken2 = this.testShare.GetSharedAccessSignature(policy2);
creds.UpdateSASToken(sasToken2);
// Extra check to make sure that we have actually updated the SAS token.
CloudFileShare share = new CloudFileShare(this.testShare.Uri, creds);
CloudFile testFile2 = share.GetRootDirectoryReference().GetFileReference("file2");
OperationContext context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await UploadTextAsync(testFile2, "file", Encoding.UTF8, operationContext: context),
context,
"Writing to a file while SAS does not allow for writing",
HttpStatusCode.Forbidden,
"");
CloudFile testFile3 = this.testShare.GetRootDirectoryReference().GetFileReference("file3");
await testFile3.CreateAsync(0);
await TestAccess(sasToken2, SharedAccessFilePermissions.Read, null, this.testShare, testFile);
}
public async Task FileOpenWriteSeekReadTestAsync()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
MemoryStream memoryStream = new MemoryStream(buffer);
using (CloudFileStream fileStream = await file.OpenWriteAsync(2048))
{
Stream fileStreamForWrite = fileStream;
await fileStreamForWrite.WriteAsync(buffer, 0, 2048);
Assert.AreEqual(fileStreamForWrite.Position, 2048);
fileStreamForWrite.Seek(1024, 0);
memoryStream.Seek(1024, 0);
Assert.AreEqual(fileStreamForWrite.Position, 1024);
byte[] testBuffer = GetRandomBuffer(1024);
await memoryStream.WriteAsync(testBuffer, 0, 1024);
await fileStreamForWrite.WriteAsync(testBuffer, 0, 1024);
Assert.AreEqual(fileStreamForWrite.Position, memoryStream.Position);
await fileStreamForWrite.FlushAsync();
}
using (Stream dstStream = await file.OpenReadAsync())
{
Stream dstStreamForRead = dstStream;
TestHelper.AssertStreamsAreEqual(memoryStream, dstStreamForRead);
}
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public async Task FileUploadWithoutMD5ValidationAndStoreFileContentTestAsync()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
FileRequestOptions options = new FileRequestOptions();
options.DisableContentMD5Validation = false;
options.StoreFileContentMD5 = false;
OperationContext context = new OperationContext();
using (MemoryStream srcStream = new MemoryStream(buffer))
{
await file.UploadFromStreamAsync(srcStream, null, options, context);
await file.FetchAttributesAsync();
string md5 = file.Properties.ContentMD5;
file.Properties.ContentMD5 = "MDAwMDAwMDA=";
await file.SetPropertiesAsync(null, options, context);
byte[] testBuffer = new byte[2048];
MemoryStream dstStream = new MemoryStream(testBuffer);
await TestHelper.ExpectedExceptionAsync(async() => await file.DownloadRangeToStreamAsync(dstStream, null, null, null, options, context),
context,
"Try to Download a stream with a corrupted md5 and DisableMD5Validation set to false",
HttpStatusCode.OK);
options.DisableContentMD5Validation = true;
await file.SetPropertiesAsync(null, options, context);
byte[] testBuffer2 = new byte[2048];
MemoryStream dstStream2 = new MemoryStream(testBuffer2);
await file.DownloadRangeToStreamAsync(dstStream2, null, null, null, options, context);
}
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public async Task FileOpenReadWithCancelTest()
{
CancellationTokenSource cts = new CancellationTokenSource();
byte[] buffer = new byte[4 * 1024 * 1024];
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
using (MemoryStream srcStream = new MemoryStream(buffer))
{
file.UploadFromStream(srcStream);
}
Stream dstStream = await file.OpenReadAsync(null, null, null, cts.Token);
cts.Cancel();
try
{
Assert.IsTrue(cts.Token.IsCancellationRequested);
int bytesRead = 0;
do
{
bytesRead = await dstStream.ReadAsync(buffer, 0, buffer.Length, cts.Token);
}while (bytesRead > 0);
Assert.Fail("Expected exception not raised");
}
catch (StorageException e)
{
Assert.AreEqual("A task was canceled.", e.Message);
}
}
finally
{
share.DeleteIfExists();
}
}
public async Task CloudFileDirectoryDeleteIfExistsAsync()
{
CloudFileShare share = GetRandomShareReference();
await share.CreateAsync();
try
{
CloudFileDirectory directory = share.GetRootDirectoryReference().GetDirectoryReference("directory1");
Assert.IsFalse(await directory.DeleteIfExistsAsync());
await directory.CreateAsync();
Assert.IsTrue(await directory.DeleteIfExistsAsync());
Assert.IsFalse(await directory.DeleteIfExistsAsync());
}
finally
{
share.DeleteAsync().Wait();
}
}
public async Task CloudFileClientMaximumExecutionTimeoutAsync()
{
CloudFileClient fileClient = GenerateCloudFileClient();
CloudFileShare share = fileClient.GetShareReference(Guid.NewGuid().ToString("N"));
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
byte[] buffer = FileTestBase.GetRandomBuffer(80 * 1024 * 1024);
try
{
await share.CreateAsync();
fileClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(5);
CloudFile file = rootDirectory.GetFileReference("file");
file.StreamWriteSizeInBytes = 1 * 1024 * 1024;
using (MemoryStream ms = new MemoryStream(buffer))
{
try
{
await file.UploadFromStreamAsync(ms);
Assert.Fail();
}
catch (AggregateException ex)
{
#if !FACADE_NETCORE
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).ExceptionInfo.Message);
#else
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).Exception.Message);
#endif
}
catch (TaskCanceledException)
{
}
}
}
finally
{
fileClient.DefaultRequestOptions.MaximumExecutionTime = null;
await share.DeleteAsync();
}
}
public void CloudFileClientObjects()
{
CloudFileClient fileClient = GenerateCloudFileClient();
CloudFileShare share = fileClient.GetShareReference("share");
Assert.AreEqual(fileClient, share.ServiceClient);
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
Assert.AreEqual(fileClient, rootDirectory.ServiceClient);
CloudFileDirectory directory = rootDirectory.GetDirectoryReference("directory");
Assert.AreEqual(fileClient, directory.ServiceClient);
CloudFile file = directory.GetFileReference("file");
Assert.AreEqual(fileClient, file.ServiceClient);
CloudFileShare share2 = GetRandomShareReference();
Assert.AreNotEqual(fileClient, share2.ServiceClient);
}
public async Task TestFileEncryptionAsync()
{
bool requestFound = false;
OperationContext ctxt = new OperationContext();
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateIfNotExistsAsync();
CloudFileDirectory directory = share.GetRootDirectoryReference();
CloudFile file = directory.GetFileReference("file");
await file.UploadTextAsync("test");
ctxt.RequestCompleted += (sender, args) =>
{
Assert.IsTrue(args.RequestInformation.IsRequestServerEncrypted);
requestFound = true;
};
await file.UploadTextAsync("test", null, null, ctxt);
Assert.IsTrue(requestFound);
requestFound = false;
await file.SetPropertiesAsync(null, null, ctxt);
Assert.IsTrue(requestFound);
requestFound = false;
await file.SetMetadataAsync(null, null, ctxt);
Assert.IsTrue(requestFound);
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public void FileReadWhenOpenWrite()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
MemoryStream memoryStream = new MemoryStream(buffer);
Stream fileStream = file.OpenWrite(2048);
fileStream.Write(buffer, 0, 2048);
byte[] testBuffer = new byte[2048];
TestHelper.ExpectedException <NotSupportedException>(() => fileStream.Read(testBuffer, 0, 2048),
"Try reading from a stream opened for Write");
}
finally
{
share.DeleteIfExists();
}
}
public async Task CloudFileDirectoryApisInvalidApisInShareSnapshotAsync()
{
CloudFileShare share = GetRandomShareReference();
await share.CreateAsync();
CloudFileShare snapshot = await share.SnapshotAsync();
CloudFileDirectory dir = snapshot.GetRootDirectoryReference().GetDirectoryReference("dir1");
try
{
dir.CreateAsync().Wait();
Assert.Fail("API should fail in a snapshot");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message);
}
try
{
dir.DeleteAsync().Wait();
Assert.Fail("API should fail in a snapshot");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message);
}
try
{
dir.SetMetadataAsync(null, null, null).Wait();
Assert.Fail("API should fail in a snapshot");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message);
}
snapshot.DeleteAsync().Wait();
share.DeleteAsync().Wait();
}
public void FileOpenReadTest()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
using (MemoryStream srcStream = new MemoryStream(buffer))
{
file.UploadFromStream(srcStream);
Stream dstStream = file.OpenRead();
TestHelper.AssertStreamsAreEqual(srcStream, dstStream);
}
}
finally
{
share.DeleteIfExists();
}
}
public void FileOpenReadWriteTest()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
Stream fileStream = file.OpenWrite(2048);
fileStream.Write(buffer, 0, 2048);
fileStream.Close();
MemoryStream memoryStream = new MemoryStream(buffer);
Stream dstStream = file.OpenRead();
TestHelper.AssertStreamsAreEqual(memoryStream, dstStream);
}
finally
{
share.DeleteIfExists();
}
}
public async Task CloudFileDirectoryApisInShareSnapshotAsync()
{
CloudFileShare share = GetRandomShareReference();
await share.CreateAsync();
CloudFileDirectory dir = share.GetRootDirectoryReference().GetDirectoryReference("dir1");
await dir.CreateAsync();
dir.Metadata["key1"] = "value1";
await dir.SetMetadataAsync(null, null, null);
CloudFileShare snapshot = await share.SnapshotAsync();
CloudFileDirectory snapshotDir = snapshot.GetRootDirectoryReference().GetDirectoryReference("dir1");
dir.Metadata["key2"] = "value2";
await dir.SetMetadataAsync(null, null, null);
await snapshotDir.FetchAttributesAsync();
Assert.IsTrue(snapshotDir.Metadata.Count == 1 && snapshotDir.Metadata["key1"].Equals("value1"));
// Metadata keys should be case-insensitive
Assert.IsTrue(snapshotDir.Metadata["KEY1"].Equals("value1"));
Assert.IsNotNull(snapshotDir.Properties.ETag);
await dir.FetchAttributesAsync();
Assert.IsTrue(dir.Metadata.Count == 2 && dir.Metadata["key2"].Equals("value2"));
// Metadata keys should be case-insensitive
Assert.IsTrue(dir.Metadata["KEY2"].Equals("value2"));
Assert.IsNotNull(dir.Properties.ETag);
Assert.AreNotEqual(dir.Properties.ETag, snapshotDir.Properties.ETag);
await snapshot.DeleteAsync();
await share.DeleteAsync();
}
public async Task FileWriteWhenOpenReadAsync()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
using (MemoryStream srcStream = new MemoryStream(buffer))
{
await file.UploadFromStreamAsync(srcStream);
bool thrown = false;
byte[] testBuffer = new byte[2048];
using (Stream fileStream = await file.OpenReadAsync())
{
Stream fileStreamForRead = fileStream;
try
{
await fileStreamForRead.WriteAsync(testBuffer, 0, 2048);
}
catch (NotSupportedException)
{
thrown = true;
}
Assert.IsTrue(thrown);
}
}
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public void FileSeekTest()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
using (MemoryStream srcStream = new MemoryStream(buffer))
{
file.UploadFromStream(srcStream);
Stream fileStream = file.OpenRead();
fileStream.Seek(2048, 0);
byte[] buff = new byte[100];
int numRead = fileStream.Read(buff, 0, 100);
Assert.AreEqual(numRead, 0);
}
}
finally
{
share.DeleteIfExists();
}
}
private async Task <bool> CloudFileDirectorySetupAsync(CloudFileShare share)
{
try
{
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
for (int i = 1; i < 3; i++)
{
CloudFileDirectory topDirectory = rootDirectory.GetDirectoryReference("TopDir" + i);
await topDirectory.CreateAsync();
for (int j = 1; j < 3; j++)
{
CloudFileDirectory midDirectory = topDirectory.GetDirectoryReference("MidDir" + j);
await midDirectory.CreateAsync();
for (int k = 1; k < 3; k++)
{
CloudFileDirectory endDirectory = midDirectory.GetDirectoryReference("EndDir" + k);
await endDirectory.CreateAsync();
CloudFile file1 = endDirectory.GetFileReference("EndFile" + k);
await file1.CreateAsync(0);
}
}
CloudFile file2 = topDirectory.GetFileReference("File" + i);
await file2.CreateAsync(0);
}
return(true);
}
catch (Exception e)
{
throw e;
}
}
public void FileReadLockToETagTestAPM()
{
byte[] outBuffer = new byte[1 * 1024 * 1024];
byte[] buffer = GetRandomBuffer(2 * outBuffer.Length);
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
file.StreamMinimumReadSizeInBytes = outBuffer.Length;
using (MemoryStream wholeFile = new MemoryStream(buffer))
{
file.UploadFromStream(wholeFile);
}
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result = file.BeginOpenRead(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
using (Stream fileStream = file.EndOpenRead(result))
{
fileStream.Read(outBuffer, 0, outBuffer.Length);
file.SetMetadata();
TestHelper.ExpectedException(
() => fileStream.Read(outBuffer, 0, outBuffer.Length),
"File read stream should fail if file is modified during read",
HttpStatusCode.PreconditionFailed);
}
result = file.BeginOpenRead(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
using (Stream fileStream = file.EndOpenRead(result))
{
long length = fileStream.Length;
file.SetMetadata();
TestHelper.ExpectedException(
() => fileStream.Read(outBuffer, 0, outBuffer.Length),
"File read stream should fail if file is modified during read",
HttpStatusCode.PreconditionFailed);
}
/*
* AccessCondition accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(DateTimeOffset.Now.Subtract(TimeSpan.FromHours(1)));
* file.SetMetadata();
* result = file.BeginOpenRead(
* accessCondition,
* null,
* null,
* ar => waitHandle.Set(),
* null);
* waitHandle.WaitOne();
* TestHelper.ExpectedException(
* () => file.EndOpenRead(result),
* "File read stream should fail if file is modified during read",
* HttpStatusCode.PreconditionFailed);
*/
}
}
finally
{
share.DeleteIfExists();
}
}
public void FileUseTransactionalMD5GetTestAPM()
{
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
UseTransactionalMD5 = false,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
UseTransactionalMD5 = true,
};
byte[] buffer = GetRandomBuffer(3 * 1024 * 1024);
MD5 hasher = MD5.Create();
string md5 = Convert.ToBase64String(hasher.ComputeHash(buffer));
string lastCheckMD5 = null;
int checkCount = 0;
OperationContext opContextWithMD5Check = new OperationContext();
opContextWithMD5Check.ResponseReceived += (_, args) =>
{
if (long.Parse(HttpResponseParsers.GetContentLength(args.Response)) >= buffer.Length)
{
lastCheckMD5 = HttpResponseParsers.GetContentMD5(args.Response);
checkCount++;
}
};
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result;
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file2");
using (Stream fileStream = file.OpenWrite(buffer.Length * 2))
{
fileStream.Write(buffer, 0, buffer.Length);
fileStream.Write(buffer, 0, buffer.Length);
}
checkCount = 0;
using (Stream stream = new MemoryStream())
{
result = file.BeginDownloadToStream(stream, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadRangeToStream(result);
Assert.IsNull(lastCheckMD5);
result = file.BeginDownloadToStream(stream, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
StorageException storageEx = TestHelper.ExpectedException <StorageException>(
() => file.EndDownloadRangeToStream(result),
"File will not have MD5 set by default; with UseTransactional, download should fail");
result = file.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadRangeToStream(result);
Assert.IsNull(lastCheckMD5);
result = file.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadRangeToStream(result);
Assert.AreEqual(md5, lastCheckMD5);
result = file.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadRangeToStream(result);
Assert.IsNull(lastCheckMD5);
result = file.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
storageEx = TestHelper.ExpectedException <StorageException>(
() => file.EndDownloadRangeToStream(result),
"Downloading more than 4MB with transactional MD5 should not be supported");
Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException));
result = file.BeginOpenRead(null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
using (Stream fileStream = file.EndOpenRead(result))
{
fileStream.CopyTo(stream);
Assert.IsNotNull(lastCheckMD5);
}
result = file.BeginOpenRead(null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
using (Stream fileStream = file.EndOpenRead(result))
{
fileStream.CopyTo(stream);
Assert.IsNull(lastCheckMD5);
}
}
Assert.AreEqual(9, checkCount);
}
}
finally
{
share.DeleteIfExists();
}
}
public void FileUseTransactionalMD5PutTestAPM()
{
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
UseTransactionalMD5 = false,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
UseTransactionalMD5 = true,
};
byte[] buffer = GetRandomBuffer(1024);
MD5 hasher = MD5.Create();
string md5 = Convert.ToBase64String(hasher.ComputeHash(buffer));
string lastCheckMD5 = null;
int checkCount = 0;
OperationContext opContextWithMD5Check = new OperationContext();
opContextWithMD5Check.SendingRequest += (_, args) =>
{
if (HttpRequestParsers.GetContentLength(args.Request) >= buffer.Length)
{
lastCheckMD5 = HttpRequestParsers.GetContentMD5(args.Request);
checkCount++;
}
};
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result;
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file2");
file.Create(buffer.Length);
checkCount = 0;
using (Stream fileData = new MemoryStream(buffer))
{
result = file.BeginWriteRange(fileData, 0, null, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndWriteRange(result);
Assert.IsNull(lastCheckMD5);
fileData.Seek(0, SeekOrigin.Begin);
result = file.BeginWriteRange(fileData, 0, null, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndWriteRange(result);
Assert.AreEqual(md5, lastCheckMD5);
fileData.Seek(0, SeekOrigin.Begin);
result = file.BeginWriteRange(fileData, 0, md5, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndWriteRange(result);
Assert.AreEqual(md5, lastCheckMD5);
}
Assert.AreEqual(3, checkCount);
}
}
finally
{
share.DeleteIfExists();
}
}
public void FileDisableContentMD5ValidationTestAPM()
{
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
DisableContentMD5Validation = true,
StoreFileContentMD5 = true,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
DisableContentMD5Validation = false,
StoreFileContentMD5 = true,
};
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result;
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file2");
using (Stream stream = new MemoryStream())
{
file.UploadFromStream(stream, null, optionsWithMD5);
}
using (Stream stream = new MemoryStream())
{
result = file.BeginDownloadToStream(stream, null, optionsWithMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadToStream(result);
result = file.BeginDownloadToStream(stream, null, optionsWithNoMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadToStream(result);
file.Properties.ContentMD5 = "MDAwMDAwMDA=";
file.SetProperties();
result = file.BeginDownloadToStream(stream, null, optionsWithMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
TestHelper.ExpectedException(
() => file.EndDownloadToStream(result),
"Downloading a file with invalid MD5 should fail",
HttpStatusCode.OK);
result = file.BeginDownloadToStream(stream, null, optionsWithNoMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadToStream(result);
}
}
}
finally
{
share.DeleteIfExists();
}
}
public void FileDisableContentMD5ValidationTest()
{
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
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file2");
using (Stream stream = new MemoryStream(buffer))
{
file.UploadFromStream(stream, null, optionsWithMD5);
}
using (Stream stream = new MemoryStream())
{
file.DownloadToStream(stream, null, optionsWithMD5);
file.DownloadToStream(stream, null, optionsWithNoMD5);
using (Stream fileStream = file.OpenRead(null, optionsWithMD5))
{
int read;
do
{
read = fileStream.Read(buffer, 0, buffer.Length);
}while (read > 0);
}
using (Stream fileStream = file.OpenRead(null, optionsWithNoMD5))
{
int read;
do
{
read = fileStream.Read(buffer, 0, buffer.Length);
}while (read > 0);
}
file.Properties.ContentMD5 = "MDAwMDAwMDA=";
file.SetProperties();
TestHelper.ExpectedException(
() => file.DownloadToStream(stream, null, optionsWithMD5),
"Downloading a file with invalid MD5 should fail",
HttpStatusCode.OK);
file.DownloadToStream(stream, null, optionsWithNoMD5);
using (Stream fileStream = file.OpenRead(null, optionsWithMD5))
{
TestHelper.ExpectedException <IOException>(
() =>
{
int read;
do
{
read = fileStream.Read(buffer, 0, buffer.Length);
}while (read > 0);
},
"Downloading a file with invalid MD5 should fail");
}
using (Stream fileStream = file.OpenRead(null, optionsWithNoMD5))
{
int read;
do
{
read = fileStream.Read(buffer, 0, buffer.Length);
}while (read > 0);
}
}
}
finally
{
share.DeleteIfExists();
}
}
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 securePort = 443;
int httpPort = (fileSASUri.Port == securePort) ? 80 : fileSASUri.Port;
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 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 (CloudFileStream fileStream = await file.OpenWriteAsync(4 * 512, null, options, opContext))
{
for (int i = 0; i < 3; i++)
{
await fileStream.WriteAsync(buffer, 0, buffer.Length);
await wholeFile.WriteAsync(buffer, 0, buffer.Length);
}
#if NETCORE
// todo: Make some other better logic for this test to be reliable.
System.Threading.Thread.Sleep(500);
#endif
Task.Delay(500).GetAwaiter().GetResult();
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, 0, buffer.Length);
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().Wait();
}
}
public async Task FileWriteStreamBasicTestAsync()
{
byte[] buffer = GetRandomBuffer(6 * 512);
#if NETCORE
MD5 hasher = MD5.Create();
#else
CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
#endif
CloudFileShare share = GetRandomShareReference();
share.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2;
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
file.StreamWriteSizeInBytes = 8 * 512;
using (MemoryStream wholeFile = new MemoryStream())
{
FileRequestOptions options = new FileRequestOptions()
{
StoreFileContentMD5 = true,
};
using (CloudFileStream writeStream = await file.OpenWriteAsync(buffer.Length * 3, null, options, null))
{
Stream fileStream = writeStream;
for (int i = 0; i < 3; i++)
{
await fileStream.WriteAsync(buffer, 0, buffer.Length);
await wholeFile.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(wholeFile.Position, fileStream.Position);
#if !NETCORE
hasher.Append(buffer.AsBuffer());
#endif
}
await fileStream.FlushAsync();
}
#if NETCORE
string md5 = Convert.ToBase64String(hasher.ComputeHash(wholeFile.ToArray()));
#else
string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset());
#endif
await file.FetchAttributesAsync();
Assert.AreEqual(md5, file.Properties.ContentMD5);
using (MemoryOutputStream downloadedFile = new MemoryOutputStream())
{
await file.DownloadToStreamAsync(downloadedFile);
TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile.UnderlyingStream);
}
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await file.OpenWriteAsync(null, null, options, null),
"OpenWrite with StoreFileContentMD5 on an existing file should fail");
using (CloudFileStream writeStream = await file.OpenWriteAsync(null))
{
Stream fileStream = writeStream;
fileStream.Seek(buffer.Length / 2, SeekOrigin.Begin);
wholeFile.Seek(buffer.Length / 2, SeekOrigin.Begin);
for (int i = 0; i < 2; i++)
{
fileStream.Write(buffer, 0, buffer.Length);
wholeFile.Write(buffer, 0, buffer.Length);
Assert.AreEqual(wholeFile.Position, fileStream.Position);
}
await fileStream.FlushAsync();
}
await file.FetchAttributesAsync();
Assert.AreEqual(md5, file.Properties.ContentMD5);
using (MemoryOutputStream downloadedFile = new MemoryOutputStream())
{
options.DisableContentMD5Validation = true;
await file.DownloadToStreamAsync(downloadedFile, null, options, null);
TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile.UnderlyingStream);
}
}
}
finally
{
share.DeleteAsync().Wait();
}
}
private static void CloudFileCopy(bool sourceIsSas, bool destinationIsSas)
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
// Create Source on server
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
string data = "String data";
UploadText(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
source.SetMetadata();
// Create Destination on server
CloudFile destination = share.GetRootDirectoryReference().GetFileReference("destination");
destination.Create(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 = copyDestination.StartCopy(TestHelper.Defiddler(copySource));
WaitForCopy(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
TestHelper.ExpectedException(
() => copyDestination.AbortCopy(copyId),
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
}
source.FetchAttributes();
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 = DownloadText(destination, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of file not equal.");
destination.FetchAttributes();
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");
destination.Delete();
source.Delete();
}
finally
{
share.DeleteIfExists();
}
}
public void FileStoreContentMD5TestAPM()
{
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
StoreFileContentMD5 = false,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
StoreFileContentMD5 = true,
};
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result;
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file4");
using (Stream stream = new MemoryStream())
{
result = file.BeginUploadFromStream(stream, null, optionsWithMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndUploadFromStream(result);
}
file.FetchAttributes();
Assert.IsNotNull(file.Properties.ContentMD5);
file = share.GetRootDirectoryReference().GetFileReference("file5");
using (Stream stream = new MemoryStream())
{
result = file.BeginUploadFromStream(stream, null, optionsWithNoMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndUploadFromStream(result);
}
file.FetchAttributes();
Assert.IsNull(file.Properties.ContentMD5);
file = share.GetRootDirectoryReference().GetFileReference("file6");
using (Stream stream = new MemoryStream())
{
result = file.BeginUploadFromStream(stream,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndUploadFromStream(result);
}
file.FetchAttributes();
Assert.IsNull(file.Properties.ContentMD5);
}
}
finally
{
share.DeleteIfExists();
}
}
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 (CloudFileStream fileStream = await file.OpenWriteAsync(8 * 1024 * 1024))
{
Stream fos = fileStream;
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 (Stream fileStream = await file.OpenReadAsync())
{
Stream fis = fileStream;
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;
await share.DeleteAsync();
}
}
private static async Task TestAccess(string sasToken, SharedAccessFilePermissions permissions, SharedAccessFileHeaders headers, CloudFileShare share, CloudFile file)
{
CloudFileShare SASshare = null;
CloudFile SASfile;
OperationContext context = new OperationContext();
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
string fileText = "file";
if (share != null)
{
SASshare = new CloudFileShare(credentials.TransformUri(share.Uri));
SASfile = SASshare.GetRootDirectoryReference().GetFileReference(file.Name);
}
else
{
SASfile = new CloudFile(credentials.TransformUri(file.Uri));
}
if ((permissions & SharedAccessFilePermissions.Write) == SharedAccessFilePermissions.Write)
{
await UploadTextAsync(SASfile, fileText, Encoding.UTF8);
}
else if ((permissions & SharedAccessFilePermissions.Create) == SharedAccessFilePermissions.Create)
{
await SASfile.CreateAsync(Encoding.UTF8.GetBytes(fileText).Length);
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await UploadTextAsync(SASfile, fileText, Encoding.UTF8, operationContext: context),
context,
"UploadText SAS does not allow for writing",
HttpStatusCode.Forbidden,
"");
await UploadTextAsync(file, fileText, Encoding.UTF8);
}
else
{
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await SASfile.CreateAsync(Encoding.UTF8.GetBytes(fileText).Length, null /* accessCondition */, null /* options */, context),
context,
"Create file succeeded but SAS does not allow for writing/creating",
HttpStatusCode.Forbidden,
"");
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await UploadTextAsync(SASfile, fileText, Encoding.UTF8, operationContext: context),
context,
"UploadText SAS does not allow for writing/creating",
HttpStatusCode.Forbidden,
"");
await UploadTextAsync(file, fileText, Encoding.UTF8);
}
if (SASshare != null)
{
if ((permissions & SharedAccessFilePermissions.List) == SharedAccessFilePermissions.List)
{
FileResultSegment results = await SASshare.GetRootDirectoryReference().ListFilesAndDirectoriesSegmentedAsync(null);
}
else
{
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => { FileResultSegment results = await SASshare.GetRootDirectoryReference().ListFilesAndDirectoriesSegmentedAsync(null /* maxResults */, null /* currentToken */, null /* options */, context); },
context,
"List files while SAS does not allow for listing",
HttpStatusCode.Forbidden,
"");
}
}
if ((permissions & SharedAccessFilePermissions.Read) == SharedAccessFilePermissions.Read)
{
await SASfile.FetchAttributesAsync();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, SASfile.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, SASfile.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, SASfile.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, SASfile.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, SASfile.Properties.ContentType);
}
}
}
else
{
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await SASfile.FetchAttributesAsync(null /* accessCondition */, null /* options */, context),
context,
"Fetch file attributes while SAS does not allow for reading",
HttpStatusCode.Forbidden,
"");
}
if ((permissions & SharedAccessFilePermissions.Write) == SharedAccessFilePermissions.Write)
{
await SASfile.SetMetadataAsync();
}
else
{
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await SASfile.SetMetadataAsync(null /* accessCondition */, null /* options */, context),
context,
"Set file metadata while SAS does not allow for writing",
HttpStatusCode.Forbidden,
"");
}
if ((permissions & SharedAccessFilePermissions.Delete) == SharedAccessFilePermissions.Delete)
{
await SASfile.DeleteAsync();
}
else
{
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await SASfile.DeleteAsync(null /* accessCondition */, null /* options */, context),
context,
"Delete file while SAS does not allow for deleting",
HttpStatusCode.Forbidden,
"");
}
}
