public Task DeleteShareAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return share.DeleteAsync(accessCondition, options, operationContext, cancellationToken);
}
public async Task CloudFileInvalidApisInShareSnapshotAsync()
{
CloudFileClient client = GenerateCloudFileClient();
string name = GetRandomShareName();
CloudFileShare share = client.GetShareReference(name);
await share.CreateAsync();
CloudFileShare snapshot = share.SnapshotAsync().Result;
CloudFile file = snapshot.GetRootDirectoryReference().GetDirectoryReference("dir1").GetFileReference("file");
try
{
await file.CreateAsync(1024);
Assert.Fail("API should fail in a snapshot");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message);
}
try
{
await file.DeleteAsync();
Assert.Fail("API should fail in a snapshot");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message);
}
try
{
await file.SetMetadataAsync();
Assert.Fail("API should fail in a snapshot");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message);
}
try
{
await file.AbortCopyAsync(null);
Assert.Fail("API should fail in a snapshot");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message);
}
try
{
await file.ClearRangeAsync(0, 1024);
Assert.Fail("API should fail in a snapshot");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message);
}
try
{
await file.StartCopyAsync(file);
Assert.Fail("API should fail in a snapshot");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message);
}
try
{
await file.UploadFromByteArrayAsync(new byte[1024], 0, 1024);
Assert.Fail("API should fail in a snapshot");
}
catch (InvalidOperationException e)
{
Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message);
}
await snapshot.DeleteAsync();
await share.DeleteAsync();
}
public async Task FileWriteStreamBasicTestAsync()
{
byte[] buffer = GetRandomBuffer(6 * 512);
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())
{
using (Stream writeStream = await file.OpenWriteAsync(buffer.Length * 3))
{
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);
}
await fileStream.FlushAsync();
}
using (MemoryStream downloadedFile = new MemoryStream())
{
await file.DownloadToStreamAsync(downloadedFile);
TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile);
}
using (Stream 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();
}
using (MemoryStream downloadedFile = new MemoryStream())
{
await file.DownloadToStreamAsync(downloadedFile);
TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile);
}
}
}
finally
{
share.DeleteAsync().Wait();
}
}
public async Task FileWriteStreamBasicTestAsync()
{
byte[] buffer = GetRandomBuffer(6 * 512);
CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
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 (IOutputStream writeStream = await file.OpenWriteAsync(buffer.Length * 3, null, options, null))
{
Stream fileStream = writeStream.AsStreamForWrite();
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);
hasher.Append(buffer.AsBuffer());
}
await fileStream.FlushAsync();
}
string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset());
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 (IOutputStream writeStream = await file.OpenWriteAsync(null))
{
Stream fileStream = writeStream.AsStreamForWrite();
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().AsTask().Wait();
}
}
public async Task CloudFileListSharesWithSnapshotAsync()
{
CloudFileShare share = GetRandomShareReference();
await share.CreateAsync();
share.Metadata["key1"] = "value1";
await share.SetMetadataAsync();
CloudFileShare snapshot = await share.SnapshotAsync();
share.Metadata["key2"] = "value2";
await share.SetMetadataAsync();
CloudFileClient client = GenerateCloudFileClient();
List <CloudFileShare> listedShares = new List <CloudFileShare>();
FileContinuationToken token = null;
do
{
ShareResultSegment resultSegment = await client.ListSharesSegmentedAsync(share.Name, ShareListingDetails.All, null, token, null, null);
token = resultSegment.ContinuationToken;
foreach (CloudFileShare listResultShare in resultSegment.Results)
{
listedShares.Add(listResultShare);
}
}while (token != null);
int count = 0;
bool originalFound = false;
bool snapshotFound = false;
foreach (CloudFileShare listShareItem in listedShares)
{
if (listShareItem.Name.Equals(share.Name) && !listShareItem.IsSnapshot && !originalFound)
{
count++;
originalFound = true;
Assert.AreEqual(2, listShareItem.Metadata.Count);
Assert.AreEqual("value2", listShareItem.Metadata["key2"]);
Assert.AreEqual("value1", listShareItem.Metadata["key1"]);
Assert.AreEqual(share.StorageUri, listShareItem.StorageUri);
}
else if (listShareItem.Name.Equals(share.Name) &&
listShareItem.IsSnapshot && !snapshotFound)
{
count++;
snapshotFound = true;
Assert.AreEqual(1, listShareItem.Metadata.Count);
Assert.AreEqual("value1", listShareItem.Metadata["key1"]);
Assert.AreEqual(snapshot.StorageUri, listShareItem.StorageUri);
}
}
Assert.AreEqual(2, count);
await snapshot.DeleteAsync();
await share.DeleteAsync();
}
