public void CloudFileShareCreate()
{
CloudFileShare share = GetRandomShareReference();
share.Create();
TestHelper.ExpectedException(
() => share.Create(),
"Creating already exists share should fail",
HttpStatusCode.Conflict);
share.Delete();
}
public void FileWriteWhenOpenRead()
{
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();
byte[] testBuffer = new byte[2048];
TestHelper.ExpectedException <NotSupportedException>(() => fileStream.Write(testBuffer, 0, 2048),
"Try writing to a stream opened for read");
}
}
finally
{
share.DeleteIfExists();
}
}
public void CloudFileDirectoryCreateAndDeleteAPM()
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
CloudFileDirectory directory = share.GetRootDirectoryReference().GetDirectoryReference("directory1");
IAsyncResult result = directory.BeginCreate(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
directory.EndCreate(result);
Assert.IsTrue(directory.Exists());
result = directory.BeginDelete(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
directory.EndDelete(result);
Assert.IsFalse(directory.Exists());
}
}
finally
{
share.Delete();
}
}
public void FileOpenWriteSeekReadTest()
{
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);
Assert.AreEqual(fileStream.Position, 2048);
fileStream.Seek(1024, 0);
memoryStream.Seek(1024, 0);
Assert.AreEqual(fileStream.Position, 1024);
byte[] testBuffer = GetRandomBuffer(1024);
memoryStream.Write(testBuffer, 0, 1024);
fileStream.Write(testBuffer, 0, 1024);
Assert.AreEqual(fileStream.Position, memoryStream.Position);
fileStream.Close();
Stream dstStream = file.OpenRead();
TestHelper.AssertStreamsAreEqual(memoryStream, dstStream);
}
finally
{
share.DeleteIfExists();
}
}
public void CloudFileDirectoryWithFilesDelete()
{
CloudFileClient client = GenerateCloudFileClient();
string name = GetRandomShareName();
CloudFileShare share = client.GetShareReference(name);
try
{
share.Create();
if (CloudFileDirectorySetup(share))
{
CloudFileDirectory dir1 = share.GetRootDirectoryReference().GetDirectoryReference("TopDir1/MidDir1/EndDir1");
CloudFile file1 = dir1.GetFileReference("EndFile1");
TestHelper.ExpectedException(
() => dir1.Delete(),
"Delete a non-empty directory",
HttpStatusCode.Conflict);
file1.Delete();
dir1.Delete();
Assert.IsFalse(file1.Exists());
Assert.IsFalse(dir1.Exists());
}
}
finally
{
share.Delete();
}
}
public void CloudFileDirectoryFileCreateWithoutDirectory()
{
CloudFileClient client = GenerateCloudFileClient();
string name = GetRandomShareName();
CloudFileShare share = client.GetShareReference(name);
try
{
share.Create();
CloudFileDirectory dir = share.GetRootDirectoryReference().GetDirectoryReference("Dir1");
CloudFile file = dir.GetFileReference("file1");
TestHelper.ExpectedException(
() => file.Create(0),
"Creating a file when the directory has not been created should throw",
HttpStatusCode.NotFound,
"ParentNotFound");
// File creation directly in the share should pass.
CloudFile file2 = share.GetRootDirectoryReference().GetFileReference("file2");
file2.Create(0);
dir.Create();
file.Create(0);
}
finally
{
share.Delete();
}
}
public void FileWriteStreamOpenAndClose()
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file");
TestHelper.ExpectedException(
() => file.OpenWrite(null),
"Opening a file stream with no size should fail on a file that does not exist",
HttpStatusCode.NotFound);
using (Stream fileStream = file.OpenWrite(1024))
{
}
using (Stream fileStream = file.OpenWrite(null))
{
}
CloudFile file2 = share.GetRootDirectoryReference().GetFileReference("file");
file2.FetchAttributes();
Assert.AreEqual(1024, file2.Properties.Length);
}
finally
{
share.Delete();
}
}
public void FileReadStreamSeekTest()
{
byte[] buffer = GetRandomBuffer(3 * 1024 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
file.StreamMinimumReadSizeInBytes = 2 * 1024 * 1024;
using (MemoryStream wholeFile = new MemoryStream(buffer))
{
file.UploadFromStream(wholeFile);
}
OperationContext opContext = new OperationContext();
using (Stream fileStream = file.OpenRead(null, null, opContext))
{
int attempts = FileReadStreamSeekTest(fileStream, file.StreamMinimumReadSizeInBytes, buffer, false);
TestHelper.AssertNAttempts(opContext, attempts);
}
opContext = new OperationContext();
using (Stream fileStream = file.OpenRead(null, null, opContext))
{
int attempts = FileReadStreamSeekTest(fileStream, file.StreamMinimumReadSizeInBytes, buffer, true);
TestHelper.AssertNAttempts(opContext, attempts);
}
}
finally
{
share.DeleteIfExists();
}
}
public void FileOpenWriteTest()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
using (CloudFileStream fileStream = file.OpenWrite(2048))
{
fileStream.Write(buffer, 0, 2048);
fileStream.Flush();
byte[] testBuffer = new byte[2048];
MemoryStream dstStream = new MemoryStream(testBuffer);
file.DownloadRangeToStream(dstStream, null, null);
MemoryStream memStream = new MemoryStream(buffer);
TestHelper.AssertStreamsAreEqual(memStream, dstStream);
}
}
finally
{
share.DeleteIfExists();
}
}
public void CloudFileShareListFilesAndDirectoriesSegmentedOverload()
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
List <string> fileNames = CreateFiles(share, 3);
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
FileContinuationToken token = null;
do
{
FileResultSegment results = rootDirectory.ListFilesAndDirectoriesSegmented(token);
int count = 0;
foreach (IListFileItem fileItem in results.Results)
{
Assert.IsInstanceOfType(fileItem, typeof(CloudFile));
Assert.IsTrue(fileNames.Remove(((CloudFile)fileItem).Name));
count++;
}
token = results.ContinuationToken;
}while (token != null);
Assert.AreEqual(0, fileNames.Count);
}
finally
{
share.DeleteIfExists();
}
}
public void CloudFileShareSetMetadata()
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFileShare share2 = share.ServiceClient.GetShareReference(share.Name);
share2.FetchAttributes();
Assert.AreEqual(0, share2.Metadata.Count);
share.Metadata.Add("key1", "value1");
share.SetMetadata();
share2.FetchAttributes();
Assert.AreEqual(1, share2.Metadata.Count);
Assert.AreEqual("value1", share2.Metadata["key1"]);
CloudFileShare share3 = share.ServiceClient.ListShares(share.Name, ShareListingDetails.Metadata).First();
Assert.AreEqual(1, share3.Metadata.Count);
Assert.AreEqual("value1", share3.Metadata["key1"]);
share.Metadata.Clear();
share.SetMetadata();
share2.FetchAttributes();
Assert.AreEqual(0, share2.Metadata.Count);
}
finally
{
share.DeleteIfExists();
}
}
public void CloudFileShareListManyFiles()
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
List <string> fileNames = CreateFiles(share, 6000);
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
int count = 0;
IEnumerable <IListFileItem> results = rootDirectory.ListFilesAndDirectories();
foreach (IListFileItem fileItem in results)
{
count++;
Assert.IsInstanceOfType(fileItem, typeof(CloudFile));
CloudFile file = (CloudFile)fileItem;
if (fileNames.Remove(file.Name))
{
Assert.IsInstanceOfType(file, typeof(CloudFile));
}
else
{
Assert.Fail("Unexpected file: " + file.Uri.AbsoluteUri);
}
}
Assert.AreEqual(6000, count);
}
finally
{
share.DeleteIfExists();
}
}
public void FileReadStreamBasicTest()
{
byte[] buffer = GetRandomBuffer(5 * 1024 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
using (MemoryStream wholeFile = new MemoryStream(buffer))
{
file.UploadFromStream(wholeFile);
}
using (MemoryStream wholeFile = new MemoryStream(buffer))
{
using (Stream fileStream = file.OpenRead())
{
TestHelper.AssertStreamsAreEqual(wholeFile, fileStream);
}
}
}
finally
{
share.DeleteIfExists();
}
}
public void FileContinuationTokenVerifyXmlWithinXml()
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
List <string> fileNames = CreateFiles(share, 3);
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
FileContinuationToken token = null;
do
{
FileResultSegment results = rootDirectory.ListFilesAndDirectoriesSegmented(1, token, null, null);
int count = 0;
foreach (IListFileItem fileItem in results.Results)
{
Assert.IsInstanceOfType(fileItem, typeof(CloudFile));
Assert.IsTrue(fileNames.Remove(((CloudFile)fileItem).Name));
count++;
}
Assert.IsTrue(count <= 1);
token = results.ContinuationToken;
if (token != null)
{
Assert.AreEqual(null, token.GetSchema());
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
StringBuilder sb = new StringBuilder();
using (XmlWriter writer = XmlWriter.Create(sb, settings))
{
writer.WriteStartElement("test1");
writer.WriteStartElement("test2");
token.WriteXml(writer);
writer.WriteEndElement();
writer.WriteEndElement();
}
using (XmlReader reader = XmlReader.Create(new StringReader(sb.ToString())))
{
token = new FileContinuationToken();
reader.ReadStartElement();
reader.ReadStartElement();
token.ReadXml(reader);
reader.ReadEndElement();
reader.ReadEndElement();
}
}
}while (token != null);
Assert.AreEqual(0, fileNames.Count);
}
finally
{
share.DeleteIfExists();
}
}
public void CloudFileShareDeleteIfExists()
{
CloudFileShare share = GetRandomShareReference();
Assert.IsFalse(share.DeleteIfExists());
share.Create();
Assert.IsTrue(share.DeleteIfExists());
Assert.IsFalse(share.DeleteIfExists());
}
public void CloudFileCopyTestWithMetadataOverride()
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
string data = "String data";
UploadText(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
source.SetMetadata();
CloudFile copy = share.GetRootDirectoryReference().GetFileReference("copy");
copy.Metadata["Test2"] = "value2";
string copyId = copy.StartCopy(TestHelper.Defiddler(source));
WaitForCopy(copy);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, copy.CopyState.TotalBytes);
Assert.AreEqual(data.Length, copy.CopyState.BytesCopied);
Assert.AreEqual(copyId, copy.CopyState.CopyId);
Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = DownloadText(copy, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of file not similar");
copy.FetchAttributes();
source.FetchAttributes();
FileProperties prop1 = copy.Properties;
FileProperties prop2 = source.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition);
Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage);
Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5);
Assert.AreEqual(prop1.ContentType, prop2.ContentType);
Assert.AreEqual("value2", copy.Metadata["Test2"], false, "Copied metadata not same");
Assert.IsFalse(copy.Metadata.ContainsKey("Test"), "Source Metadata should not appear in destination file");
copy.Delete();
}
finally
{
share.DeleteIfExists();
}
}
public void CloudFileDirectoryListFilesAndDirectories()
{
CloudFileClient client = GenerateCloudFileClient();
string name = GetRandomShareName();
CloudFileShare share = client.GetShareReference(name);
try
{
share.Create();
if (CloudFileDirectorySetup(share))
{
CloudFileDirectory topDir1 = share.GetRootDirectoryReference().GetDirectoryReference("TopDir1");
IEnumerable <IListFileItem> list1 = topDir1.ListFilesAndDirectories();
List <IListFileItem> simpleList1 = list1.ToList();
////Check if for 3 because if there were more than 3, the previous assert would have failed.
////So the only thing we need to make sure is that it is not less than 3.
Assert.IsTrue(simpleList1.Count == 3);
IListFileItem item11 = simpleList1.ElementAt(0);
Assert.IsTrue(item11.Uri.Equals(share.Uri + "/TopDir1/File1"));
Assert.AreEqual("File1", ((CloudFile)item11).Name);
IListFileItem item12 = simpleList1.ElementAt(1);
Assert.IsTrue(item12.Uri.Equals(share.Uri + "/TopDir1/MidDir1"));
Assert.AreEqual("MidDir1", ((CloudFileDirectory)item12).Name);
IListFileItem item13 = simpleList1.ElementAt(2);
Assert.IsTrue(item13.Uri.Equals(share.Uri + "/TopDir1/MidDir2"));
Assert.AreEqual("MidDir2", ((CloudFileDirectory)item13).Name);
CloudFileDirectory midDir2 = (CloudFileDirectory)item13;
IEnumerable <IListFileItem> list2 = midDir2.ListFilesAndDirectories();
List <IListFileItem> simpleList2 = list2.ToList();
Assert.IsTrue(simpleList2.Count == 2);
IListFileItem item21 = simpleList2.ElementAt(0);
Assert.IsTrue(item21.Uri.Equals(share.Uri + "/TopDir1/MidDir2/EndDir1"));
Assert.AreEqual("EndDir1", ((CloudFileDirectory)item21).Name);
IListFileItem item22 = simpleList2.ElementAt(1);
Assert.IsTrue(item22.Uri.Equals(share.Uri + "/TopDir1/MidDir2/EndDir2"));
Assert.AreEqual("EndDir2", ((CloudFileDirectory)item22).Name);
}
}
finally
{
share.DeleteIfExists();
}
}
public void FileReadLockToETagTest()
{
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 (Stream fileStream = file.OpenRead())
{
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);
}
using (Stream fileStream = file.OpenRead())
{
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();
* TestHelper.ExpectedException(
* () => file.OpenRead(accessCondition),
* "File read stream should fail if file is modified during read",
* HttpStatusCode.PreconditionFailed);
*/
}
finally
{
share.DeleteIfExists();
}
}
public void FileWriteStreamOneByteTest()
{
byte buffer = 127;
MD5 hasher = MD5.Create();
CloudFileShare share = GetRandomShareReference();
share.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2;
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
file.StreamWriteSizeInBytes = 16 * 1024;
using (MemoryStream wholeFile = new MemoryStream())
{
FileRequestOptions options = new FileRequestOptions()
{
StoreFileContentMD5 = true,
};
using (Stream fileStream = file.OpenWrite(1 * 1024 * 1024, null, options))
{
for (int i = 0; i < 1 * 1024 * 1024; i++)
{
fileStream.WriteByte(buffer);
wholeFile.WriteByte(buffer);
Assert.AreEqual(wholeFile.Position, fileStream.Position);
}
}
wholeFile.Seek(0, SeekOrigin.Begin);
string md5 = Convert.ToBase64String(hasher.ComputeHash(wholeFile));
file.FetchAttributes();
Assert.AreEqual(md5, file.Properties.ContentMD5);
using (MemoryStream downloadedFile = new MemoryStream())
{
file.DownloadToStream(downloadedFile);
TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile);
}
}
}
finally
{
share.DeleteIfExists();
}
}
public void CloudFileClientCreateShareSharedKeyLite()
{
CloudFileClient fileClient = GenerateCloudFileClient();
fileClient.AuthenticationScheme = AuthenticationScheme.SharedKeyLite;
string shareName = GetRandomShareName();
CloudFileShare share = fileClient.GetShareReference(shareName);
share.Create();
bool exists = share.Exists();
Assert.IsTrue(exists);
share.Delete();
}
public void CloudFileDirectoryWithFilesDeleteAPM()
{
CloudFileClient client = GenerateCloudFileClient();
string name = GetRandomShareName();
CloudFileShare share = client.GetShareReference(name);
try
{
share.Create();
if (CloudFileDirectorySetup(share))
{
CloudFileDirectory dir1 = share.GetRootDirectoryReference().GetDirectoryReference("TopDir1/MidDir1/EndDir1");
CloudFile file1 = dir1.GetFileReference("EndFile1");
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result = dir1.BeginDelete(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
TestHelper.ExpectedException(
() => dir1.EndDelete(result),
"Delete a non-empty directory",
HttpStatusCode.Conflict);
result = file1.BeginDelete(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file1.EndDelete(result);
result = dir1.BeginDelete(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
dir1.EndDelete(result);
}
Assert.IsFalse(file1.Exists());
Assert.IsFalse(dir1.Exists());
}
}
finally
{
share.Delete();
}
}
public void FileStoreContentMD5Test()
{
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
StoreFileContentMD5 = false,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
StoreFileContentMD5 = true,
};
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file4");
using (Stream stream = new MemoryStream())
{
file.UploadFromStream(stream, null, optionsWithMD5);
}
file.FetchAttributes();
Assert.IsNotNull(file.Properties.ContentMD5);
file = share.GetRootDirectoryReference().GetFileReference("file5");
using (Stream stream = new MemoryStream())
{
file.UploadFromStream(stream, null, optionsWithNoMD5);
}
file.FetchAttributes();
Assert.IsNull(file.Properties.ContentMD5);
file = share.GetRootDirectoryReference().GetFileReference("file6");
using (Stream stream = new MemoryStream())
{
file.UploadFromStream(stream);
}
file.FetchAttributes();
Assert.IsNull(file.Properties.ContentMD5);
}
finally
{
share.DeleteIfExists();
}
}
public void FileWriteStreamRandomSeekTest()
{
byte[] buffer = GetRandomBuffer(3 * 1024 * 1024);
CloudFileShare share = GetRandomShareReference();
share.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2;
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
using (MemoryStream wholeFile = new MemoryStream())
{
using (Stream fileStream = file.OpenWrite(buffer.Length))
{
fileStream.Write(buffer, 0, buffer.Length);
wholeFile.Write(buffer, 0, buffer.Length);
Random random = new Random();
for (int i = 0; i < 10; i++)
{
int offset = random.Next(buffer.Length);
TestHelper.SeekRandomly(fileStream, offset);
fileStream.Write(buffer, 0, buffer.Length - offset);
wholeFile.Seek(offset, SeekOrigin.Begin);
wholeFile.Write(buffer, 0, buffer.Length - offset);
}
}
file.FetchAttributes();
Assert.IsNull(file.Properties.ContentMD5);
using (MemoryStream downloadedFile = new MemoryStream())
{
file.DownloadToStream(downloadedFile);
TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile);
}
}
}
finally
{
share.DeleteIfExists();
}
}
public void CloudFileDirectoryDeleteIfExists()
{
CloudFileShare share = GetRandomShareReference();
share.Create();
try
{
CloudFileDirectory directory = share.GetRootDirectoryReference().GetDirectoryReference("directory1");
Assert.IsFalse(directory.DeleteIfExists());
directory.Create();
Assert.IsTrue(directory.DeleteIfExists());
Assert.IsFalse(directory.DeleteIfExists());
}
finally
{
share.Delete();
}
}
public void CloudFileShareRegionalSetMetadata()
{
CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("sk-SK");
CloudFileShare share = GetRandomShareReference();
try
{
share.Metadata.Add("sequence", "value");
share.Metadata.Add("schema", "value");
share.Create();
}
finally
{
Thread.CurrentThread.CurrentCulture = currentCulture;
share.DeleteIfExists();
}
}
private void FileDirectoryEscapingTest(string directoryName, string fileName)
{
CloudFileClient service = GenerateCloudFileClient();
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
string text = Guid.NewGuid().ToString();
// Create from CloudFileShare.
CloudFileDirectory directory = share.GetRootDirectoryReference().GetDirectoryReference(directoryName);
directory.Create();
CloudFile originalFile = directory.GetFileReference(fileName);
originalFile.Create(0);
// List directories from share.
IListFileItem directoryFromShareListingFiles = share.GetRootDirectoryReference().ListFilesAndDirectories().First();
Assert.AreEqual(directory.Uri, directoryFromShareListingFiles.Uri);
// List files from directory.
IListFileItem fileFromDirectoryListingFiles = directory.ListFilesAndDirectories().First();
Assert.AreEqual(originalFile.Uri, fileFromDirectoryListingFiles.Uri);
// Check Name
Assert.AreEqual <string>(fileName, originalFile.Name);
// Absolute URI access from CloudFile
CloudFile fileInfo = new CloudFile(originalFile.Uri, service.Credentials);
fileInfo.FetchAttributes();
// Access from CloudFileDirectory
CloudFileDirectory cloudFileDirectory = share.GetRootDirectoryReference().GetDirectoryReference(directoryName);
CloudFile fileFromCloudFileDirectory = cloudFileDirectory.GetFileReference(fileName);
Assert.AreEqual(fileInfo.Uri, fileFromCloudFileDirectory.Uri);
}
finally
{
share.Delete();
}
}
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 void CloudFileShareExists()
{
CloudFileShare share = GetRandomShareReference();
CloudFileShare share2 = share.ServiceClient.GetShareReference(share.Name);
Assert.IsFalse(share2.Exists());
share.Create();
try
{
Assert.IsTrue(share2.Exists());
Assert.IsNotNull(share2.Properties.ETag);
}
finally
{
share.Delete();
}
Assert.IsFalse(share2.Exists());
}
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 CloudFileShareCreateWithMetadata()
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Metadata.Add("key1", "value1");
share.Create();
CloudFileShare share2 = share.ServiceClient.GetShareReference(share.Name);
share2.FetchAttributes();
Assert.AreEqual(1, share2.Metadata.Count);
Assert.AreEqual("value1", share2.Metadata["key1"]);
Assert.IsTrue(share2.Properties.LastModified.Value.AddHours(1) > DateTimeOffset.Now);
Assert.IsNotNull(share2.Properties.ETag);
}
finally
{
share.DeleteIfExists();
}
}
