internal void NewContainerTest(Agent agent)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("astoria-");
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Container, NEW_CONTAINER_NAME);
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> > {
dic
};
// delete container if it exists
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.DeleteIfExists();
try
{
//--------------New operation--------------
Test.Assert(agent.NewAzureStorageContainer(NEW_CONTAINER_NAME), Utility.GenComparisonData("NewAzureStorageContainer", true));
// Verification for returned values
CloudBlobUtil.PackContainerCompareData(container, dic);
agent.OutputValidation(comp);
Test.Assert(container.Exists(), "container {0} should exist!", NEW_CONTAINER_NAME);
}
finally
{
// clean up
container.DeleteIfExists();
}
}
internal void GetContainerTest(Agent agent)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("astoria-");
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Container, NEW_CONTAINER_NAME);
// create container if it does not exist
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> > {
dic
};
try
{
//--------------Get operation--------------
Test.Assert(agent.GetAzureStorageContainer(NEW_CONTAINER_NAME), Utility.GenComparisonData("GetAzureStorageContainer", true));
// Verification for returned values
container.FetchAttributes();
dic.Add("CloudBlobContainer", container);
CloudBlobUtil.PackContainerCompareData(container, dic);
agent.OutputValidation(comp);
}
finally
{
// clean up
container.DeleteIfExists();
}
}
internal void UploadBlobTestGB(Agent agent, StorageBlob.BlobType blobType)
{
string uploadFilePath = @".\" + Utility.GenNameString("gbupload");
string containerName = Utility.GenNameString("gbupload-");
string blobName = Path.GetFileName(uploadFilePath);
// create the container
StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName);
// Generate a 512 bytes file which contains GB18030 characters
File.WriteAllText(uploadFilePath, GB18030String);
try
{
//--------------Upload operation--------------
Test.Assert(agent.SetAzureStorageBlobContent(uploadFilePath, containerName, blobType),
Utility.GenComparisonData("SendAzureStorageBlob", true));
StorageBlob.ICloudBlob blob = CloudBlobUtil.GetBlob(container, blobName, blobType);
Test.Assert(blob != null && blob.Exists(), "blob " + blobName + " should exist!");
// Check MD5
string localMd5 = Helper.GetFileContentMD5(uploadFilePath);
blob.FetchAttributes();
Test.Assert(localMd5 == blob.Properties.ContentMD5,
string.Format("blob content md5 should be {0}, and actualy it's {1}", localMd5, blob.Properties.ContentMD5));
}
finally
{
// cleanup
container.DeleteIfExists();
File.Delete(uploadFilePath);
}
}
/// <summary>
/// Parameters:
/// Block:
/// True for BlockBlob, false for PageBlob
/// </summary>
internal void UploadBlobTest(Agent agent, string UploadFilePath, Microsoft.WindowsAzure.Storage.Blob.BlobType Type)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("upload-");
string blobName = Path.GetFileName(UploadFilePath);
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >();
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Blob, blobName);
dic["BlobType"] = Type;
comp.Add(dic);
// create the container
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
try
{
//--------------Upload operation--------------
Test.Assert(agent.SetAzureStorageBlobContent(UploadFilePath, NEW_CONTAINER_NAME, Type), Utility.GenComparisonData("SendAzureStorageBlob", true));
StorageBlob.ICloudBlob blob = CommonBlobHelper.QueryBlob(NEW_CONTAINER_NAME, blobName);
CloudBlobUtil.PackBlobCompareData(blob, dic);
// Verification for returned values
agent.OutputValidation(comp);
Test.Assert(blob != null && blob.Exists(), "blob " + blobName + " should exist!");
}
finally
{
// cleanup
container.DeleteIfExists();
}
}
public void DeleteBlobContainer(string toDelete = null)
{
var containerToDelete = !string.IsNullOrEmpty(toDelete) ? toDelete : containerName;
var blobClient = storageAccount.CreateCloudBlobClient();
container = blobClient.GetContainerReference(containerToDelete);
container.DeleteIfExists();
}
internal void CopyBlobTestGB(Agent agent, StorageBlob.BlobType blobType)
{
string uploadFilePath = @".\" + Utility.GenNameString("gbupload");
string srcContainerName = Utility.GenNameString("gbupload-", 15);
string destContainerName = Utility.GenNameString("gbupload-", 15);
string blobName = Path.GetFileName(uploadFilePath);
// create the container
StorageBlob.CloudBlobContainer srcContainer = blobUtil.CreateContainer(srcContainerName);
StorageBlob.CloudBlobContainer destContainer = blobUtil.CreateContainer(destContainerName);
// Generate a 512 bytes file which contains GB18030 characters
File.WriteAllText(uploadFilePath, GB18030String);
string localMd5 = Helper.GetFileContentMD5(uploadFilePath);
try
{
// create source blob
StorageBlob.ICloudBlob blob = CloudBlobUtil.GetBlob(srcContainer, blobName, blobType);
// upload file data
using (var fileStream = System.IO.File.OpenRead(uploadFilePath))
{
blob.UploadFromStream(fileStream);
// need to set MD5 as for page blob, it won't set MD5 automatically
blob.Properties.ContentMD5 = localMd5;
blob.SetProperties();
}
//--------------Copy blob operation--------------
Test.Assert(agent.StartAzureStorageBlobCopy(srcContainerName, blobName, destContainerName, blobName), Utility.GenComparisonData("Start copy blob using blob name", true));
// Get destination blob
blob = CloudBlobUtil.GetBlob(destContainer, blobName, blobType);
// Check MD5
blob.FetchAttributes();
Test.Assert(localMd5 == blob.Properties.ContentMD5,
string.Format("blob content md5 should be {0}, and actualy it's {1}", localMd5, blob.Properties.ContentMD5));
}
finally
{
// cleanup
srcContainer.DeleteIfExists();
destContainer.DeleteIfExists();
File.Delete(uploadFilePath);
}
}
public void CloudBlockBlobDownloadToStreamAPMCancel()
{
byte[] buffer = GetRandomBuffer(1 * 1024 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudBlockBlob blob = container.GetBlockBlobReference("blob1");
using (MemoryStream originalBlob = new MemoryStream(buffer))
{
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
ICancellableAsyncResult result = blob.BeginUploadFromStream(originalBlob,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blob.EndUploadFromStream(result);
using (MemoryStream downloadedBlob = new MemoryStream())
{
OperationContext operationContext = new OperationContext();
result = blob.BeginDownloadToStream(downloadedBlob, null, null, operationContext,
ar => waitHandle.Set(),
null);
Thread.Sleep(100);
result.Cancel();
waitHandle.WaitOne();
try
{
blob.EndDownloadToStream(result);
}
catch (StorageException ex)
{
Assert.AreEqual(ex.Message, "Operation was canceled by user.");
Assert.AreEqual(ex.RequestInformation.HttpStatusCode, 306);
Assert.AreEqual(ex.RequestInformation.HttpStatusMessage, "Unused");
}
TestHelper.AssertNAttempts(operationContext, 1);
}
}
}
}
finally
{
container.DeleteIfExists();
}
}
public void PageBlobReadStreamReadSizeTest()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
BlobReadStreamReadSizeTest(blob);
}
finally
{
container.DeleteIfExists();
}
}
public async Task LargeDownloadVerifyRangeSizeRestrictions()
{
string inputFileName = Path.GetTempFileName();
string outputFileName = Path.GetTempFileName();
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blob = container.GetBlockBlobReference("largeblob1");
await blob.UploadTextAsync("Tent");
try
{
await blob.DownloadToFileParallelAsync(outputFileName, FileMode.Create, 16, 16 *Constants.MB + 3, CancellationToken.None);
Assert.Fail("Expected a failure");
}
catch (ArgumentException) {}
try
{
await blob.DownloadToFileParallelAsync(outputFileName, FileMode.Create, 16, 2 *Constants.MB, CancellationToken.None);
Assert.Fail("Expected a failure");
}
catch (ArgumentOutOfRangeException) {}
try
{
BlobRequestOptions options = new BlobRequestOptions();
options.UseTransactionalMD5 = true;
await blob.DownloadToFileParallelAsync(outputFileName, FileMode.Create, 16, 16 *Constants.MB, 0, null, null, options, null, CancellationToken.None);
Assert.Fail("Expected a failure");
}
catch (ArgumentException) {}
blob.Delete();
}
finally
{
container.DeleteIfExists();
File.Delete(inputFileName);
File.Delete(outputFileName);
}
}
public void CloudBlobContainerExists()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
Assert.IsFalse(container.Exists());
container.Create();
Assert.IsTrue(container.Exists());
}
finally
{
container.DeleteIfExists();
}
Assert.IsFalse(container.Exists());
}
public void PageBlobWriteStreamOneByteTest()
{
byte buffer = 127;
MD5 hasher = MD5.Create();
CloudBlobContainer container = GetRandomContainerReference();
container.ServiceClient.ParallelOperationThreadCount = 2;
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = 16 * 1024;
using (MemoryStream wholeBlob = new MemoryStream())
{
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
using (Stream blobStream = blob.OpenWrite(1 * 1024 * 1024, null, options))
{
for (int i = 0; i < 1 * 1024 * 1024; i++)
{
blobStream.WriteByte(buffer);
wholeBlob.WriteByte(buffer);
Assert.AreEqual(wholeBlob.Position, blobStream.Position);
}
}
wholeBlob.Seek(0, SeekOrigin.Begin);
string md5 = Convert.ToBase64String(hasher.ComputeHash(wholeBlob));
blob.FetchAttributes();
Assert.AreEqual(md5, blob.Properties.ContentMD5);
using (MemoryStream downloadedBlob = new MemoryStream())
{
blob.DownloadToStream(downloadedBlob);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob);
}
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobDirectoryGetParent()
{
foreach (String delimiter in Delimiters)
{
CloudBlobClient client = GenerateCloudBlobClient();
client.DefaultDelimiter = delimiter;
string name = GetRandomContainerName();
CloudBlobContainer container = client.GetContainerReference(name);
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("Dir1" + delimiter + "Blob1");
blob.Create(0);
Assert.AreEqual("Dir1" + delimiter + "Blob1", blob.Name);
// get the blob's parent
CloudBlobDirectory parent = blob.Parent;
Assert.AreEqual(parent.Prefix, "Dir1" + delimiter);
// get container as parent
CloudBlobDirectory root = parent.Parent;
Assert.AreEqual(root.Prefix, "");
// make sure the parent of the container dir is null
CloudBlobDirectory empty = root.Parent;
Assert.IsNull(empty);
// from container, get directory reference to container
root = container.GetDirectoryReference("");
Assert.AreEqual("", root.Prefix);
Assert.AreEqual(container.Uri.AbsoluteUri, root.Uri.AbsoluteUri);
List <IListBlobItem> list = root.ListBlobs().ToList();
Assert.AreEqual(1, list.Count);
// make sure the parent of the container dir is null
empty = root.Parent;
Assert.IsNull(empty);
blob.DeleteIfExists();
}
finally
{
container.DeleteIfExists();
}
}
}
/// <summary>
/// Parameters:
/// Block:
/// True for BlockBlob, false for PageBlob
/// </summary>
internal void DownloadBlobTest(Agent agent, string UploadFilePath, string DownloadDirPath, Microsoft.WindowsAzure.Storage.Blob.BlobType Type)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("upload-");
string blobName = Path.GetFileName(UploadFilePath);
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >();
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Blob, blobName);
dic["BlobType"] = Type;
comp.Add(dic);
// create the container
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
try
{
bool bSuccess = false;
// upload the blob file
if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.BlockBlob)
{
bSuccess = CommonBlobHelper.UploadFileToBlockBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
else if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.PageBlob)
{
bSuccess = CommonBlobHelper.UploadFileToPageBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
Test.Assert(bSuccess, "upload file {0} to container {1} should succeed", UploadFilePath, NEW_CONTAINER_NAME);
//--------------Download operation--------------
string downloadFilePath = Path.Combine(DownloadDirPath, blobName);
Test.Assert(agent.GetAzureStorageBlobContent(blobName, downloadFilePath, NEW_CONTAINER_NAME),
Utility.GenComparisonData("GetAzureStorageBlobContent", true));
StorageBlob.ICloudBlob blob = CommonBlobHelper.QueryBlob(NEW_CONTAINER_NAME, blobName);
CloudBlobUtil.PackBlobCompareData(blob, dic);
// Verification for returned values
agent.OutputValidation(comp);
Test.Assert(Helper.CompareTwoFiles(downloadFilePath, UploadFilePath),
String.Format("File '{0}' should be bit-wise identicial to '{1}'", downloadFilePath, UploadFilePath));
}
finally
{
// cleanup
container.DeleteIfExists();
}
}
/// <summary>
/// Parameters:
/// Block:
/// True for BlockBlob, false for PageBlob
/// </summary>
internal void GetBlobTest(Agent agent, string UploadFilePath, Microsoft.WindowsAzure.Storage.Blob.BlobType Type)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("upload-");
string blobName = Path.GetFileName(UploadFilePath);
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >();
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Blob, blobName);
dic["BlobType"] = Type;
comp.Add(dic);
// create the container
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
try
{
bool bSuccess = false;
// upload the blob file
if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.BlockBlob)
{
bSuccess = CommonBlobHelper.UploadFileToBlockBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
else if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.PageBlob)
{
bSuccess = CommonBlobHelper.UploadFileToPageBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
Test.Assert(bSuccess, "upload file {0} to container {1} should succeed", UploadFilePath, NEW_CONTAINER_NAME);
//--------------Get operation--------------
Test.Assert(agent.GetAzureStorageBlob(blobName, NEW_CONTAINER_NAME), Utility.GenComparisonData("GetAzureStorageBlob", true));
// Verification for returned values
// get blob object using XSCL
StorageBlob.ICloudBlob blob = CommonBlobHelper.QueryBlob(NEW_CONTAINER_NAME, blobName);
blob.FetchAttributes();
CloudBlobUtil.PackBlobCompareData(blob, dic);
dic.Add("ICloudBlob", blob);
agent.OutputValidation(comp);
}
finally
{
// cleanup
container.DeleteIfExists();
}
}
public void CloudBlobSnapshotMetadataAPM()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudAppendBlob appendBlob = container.GetAppendBlobReference(BlobName);
appendBlob.CreateOrReplace();
CloudBlob blob = container.GetBlobReference(BlobName);
blob.Metadata["Hello"] = "World";
blob.Metadata["Marco"] = "Polo";
blob.SetMetadata();
IDictionary <string, string> snapshotMetadata = new Dictionary <string, string>();
snapshotMetadata["Hello"] = "Dolly";
snapshotMetadata["Yoyo"] = "Ma";
IAsyncResult result;
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
result = blob.BeginSnapshot(snapshotMetadata, null, null, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
CloudBlob snapshot = blob.EndSnapshot(result);
// Test the client view against the expected metadata
// None of the original metadata should be present
Assert.AreEqual("Dolly", snapshot.Metadata["Hello"]);
Assert.AreEqual("Ma", snapshot.Metadata["Yoyo"]);
Assert.IsFalse(snapshot.Metadata.ContainsKey("Marco"));
// Test the server view against the expected metadata
snapshot.FetchAttributes();
Assert.AreEqual("Dolly", snapshot.Metadata["Hello"]);
Assert.AreEqual("Ma", snapshot.Metadata["Yoyo"]);
Assert.IsFalse(snapshot.Metadata.ContainsKey("Marco"));
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobContainerSetMetadataAPMCancel()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
container.Metadata.Add("key1", "value1");
TestHelper.ExecuteAPMMethodWithCancellation(4000,
new[] { DelayBehaviors.DelayAllRequestsIf(4000 * 3, AzureStorageSelectors.BlobTraffic().IfHostNameContains(container.ServiceClient.Credentials.AccountName)) },
(options, opContext, callback, state) => container.BeginSetMetadata(null, (BlobRequestOptions)options, opContext, callback, state),
container.EndSetMetadata);
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobContainerSetPermissions()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
BlobContainerPermissions permissions = container.GetPermissions();
Assert.AreEqual(BlobContainerPublicAccessType.Off, permissions.PublicAccess);
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);
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
permissions.SharedAccessPolicies.Add("key1", new SharedAccessBlobPolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = SharedAccessBlobPermissions.List,
});
container.SetPermissions(permissions);
Thread.Sleep(30 * 1000);
CloudBlobContainer container2 = container.ServiceClient.GetContainerReference(container.Name);
permissions = container2.GetPermissions();
Assert.AreEqual(BlobContainerPublicAccessType.Container, permissions.PublicAccess);
Assert.AreEqual(1, permissions.SharedAccessPolicies.Count);
Assert.IsTrue(permissions.SharedAccessPolicies["key1"].SharedAccessStartTime.HasValue);
Assert.AreEqual(start, permissions.SharedAccessPolicies["key1"].SharedAccessStartTime.Value.UtcDateTime);
Assert.IsTrue(permissions.SharedAccessPolicies["key1"].SharedAccessExpiryTime.HasValue);
Assert.AreEqual(expiry, permissions.SharedAccessPolicies["key1"].SharedAccessExpiryTime.Value.UtcDateTime);
Assert.AreEqual(SharedAccessBlobPermissions.List, permissions.SharedAccessPolicies["key1"].Permissions);
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobDirectoryMultipleDelimiters()
{
foreach (String delimiter in Delimiters)
{
CloudBlobClient client = GenerateCloudBlobClient();
////Set the default delimiter to \
client.DefaultDelimiter = delimiter;
string name = GetRandomContainerName();
CloudBlobContainer container = client.GetContainerReference(name);
try
{
container.Create();
if (CloudBlobDirectorySetupWithDelimiter(container, delimiter))
{
IEnumerable <IListBlobItem> list1 = container.ListBlobs("TopDir1" + delimiter, false, BlobListingDetails.None, null, null);
List <IListBlobItem> 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);
IListBlobItem item11 = simpleList1.ElementAt(0);
Assert.IsTrue(item11.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "Blob1"));
IListBlobItem item12 = simpleList1.ElementAt(1);
Assert.IsTrue(item12.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter));
IListBlobItem item13 = simpleList1.ElementAt(2);
Assert.IsTrue(item13.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir2" + delimiter));
CloudBlobDirectory directory = container.GetDirectoryReference("TopDir1" + delimiter);
CloudBlobDirectory subDirectory = directory.GetSubdirectoryReference("MidDir1" + delimiter);
CloudBlobDirectory parent = subDirectory.Parent;
Assert.AreEqual(parent.Prefix, directory.Prefix);
Assert.AreEqual(parent.Uri, directory.Uri);
}
}
finally
{
container.DeleteIfExists();
}
}
}
internal void SetContainerACLTest(Agent agent)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("astoria-");
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >();
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Container, NEW_CONTAINER_NAME);
comp.Add(dic);
// create container if it does not exist
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
try
{
StorageBlob.BlobContainerPublicAccessType[] accessTypes = new StorageBlob.BlobContainerPublicAccessType[] {
StorageBlob.BlobContainerPublicAccessType.Blob,
StorageBlob.BlobContainerPublicAccessType.Container,
StorageBlob.BlobContainerPublicAccessType.Off
};
// set PublicAccess as one value respetively
foreach (var accessType in accessTypes)
{
//--------------Set operation--------------
Test.Assert(agent.SetAzureStorageContainerACL(NEW_CONTAINER_NAME, accessType),
"SetAzureStorageContainerACL operation should succeed");
// Verification for returned values
dic["PublicAccess"] = accessType;
CloudBlobUtil.PackContainerCompareData(container, dic);
agent.OutputValidation(comp);
Test.Assert(container.GetPermissions().PublicAccess == accessType,
"PublicAccess should be equal: {0} = {1}", container.GetPermissions().PublicAccess, accessType);
}
}
finally
{
// clean up
container.DeleteIfExists();
}
}
internal void RemoveContainerTest(Agent agent)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("astoria-");
// create container if it does not exist
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
try
{
//--------------Remove operation--------------
Test.Assert(agent.RemoveAzureStorageContainer(NEW_CONTAINER_NAME), Utility.GenComparisonData("RemoveAzureStorageContainer", true));
Test.Assert(!container.Exists(), "container {0} should not exist!", NEW_CONTAINER_NAME);
}
finally
{
// clean up
container.DeleteIfExists();
}
}
public void CloudBlobContainerRegionalSetMetadata()
{
CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("sk-SK");
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Metadata.Add("sequence", "value");
container.Metadata.Add("schema", "value");
container.Create();
}
finally
{
Thread.CurrentThread.CurrentCulture = currentCulture;
container.DeleteIfExists();
}
}
public void PageBlobDownloadToStreamRangeTest()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
using (MemoryStream wholeBlob = new MemoryStream(buffer))
{
blob.UploadFromStream(wholeBlob);
byte[] testBuffer = new byte[1024];
MemoryStream blobStream = new MemoryStream(testBuffer);
StorageException storageEx = TestHelper.ExpectedException <StorageException>(
() => blob.DownloadRangeToStream(blobStream, 0, 0),
"Requesting 0 bytes when downloading range should not work");
Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException));
blob.DownloadRangeToStream(blobStream, 0, 1024);
Assert.AreEqual(blobStream.Position, 1024);
TestHelper.AssertStreamsAreEqualAtIndex(blobStream, wholeBlob, 0, 0, 1024);
CloudPageBlob blob2 = container.GetPageBlobReference("blob1");
MemoryStream blobStream2 = new MemoryStream(testBuffer);
storageEx = TestHelper.ExpectedException <StorageException>(
() => blob2.DownloadRangeToStream(blobStream, 1024, 0),
"Requesting 0 bytes when downloading range should not work");
Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException));
blob2.DownloadRangeToStream(blobStream2, 1024, 1024);
TestHelper.AssertStreamsAreEqualAtIndex(blobStream2, wholeBlob, 0, 1024, 1024);
AssertAreEqual(blob, blob2);
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobSASUnknownParams()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
// Create Source on server
CloudBlockBlob blob = container.GetBlockBlobReference("source");
string data = "String data";
UploadText(blob, data, Encoding.UTF8);
UriBuilder blobURIBuilder = new UriBuilder(blob.Uri);
blobURIBuilder.Query = "MyQuery=value&YOURQUERY=value2"; // Add the query params unknown to the service
// Source SAS must have read permissions
SharedAccessBlobPermissions permissions = SharedAccessBlobPermissions.Read;
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = permissions,
};
string sasToken = blob.GetSharedAccessSignature(policy);
// Replace one of the SAS keys with a capitalized version to ensure we are case-insensitive on expected parameter keys as well
StorageCredentials credentials = new StorageCredentials(sasToken);
StringBuilder sasString = new StringBuilder(credentials.TransformUri(blobURIBuilder.Uri).ToString());
sasString.Replace("sp=", "SP=");
CloudBlockBlob sasBlob = new CloudBlockBlob(new Uri(sasString.ToString()));
// Validate that we can fetch the attributes on the blob (no exception thrown)
sasBlob.FetchAttributes();
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobDirectoryDelimitersInARow()
{
foreach (String delimiter in Delimiters)
{
CloudBlobClient client = GenerateCloudBlobClient();
client.DefaultDelimiter = delimiter;
string name = GetRandomContainerName();
CloudBlobContainer container = client.GetContainerReference(name);
try
{
CloudPageBlob blob = container.GetPageBlobReference(delimiter + delimiter + delimiter + "Blob1");
////Traverse from leaf to root
CloudBlobDirectory directory1 = blob.Parent;
Assert.AreEqual(directory1.Prefix, delimiter + delimiter + delimiter);
CloudBlobDirectory directory2 = directory1.Parent;
Assert.AreEqual(directory2.Prefix, delimiter + delimiter);
CloudBlobDirectory directory3 = directory2.Parent;
Assert.AreEqual(directory3.Prefix, delimiter);
////Traverse from root to leaf
CloudBlobDirectory directory4 = container.GetDirectoryReference(delimiter);
CloudBlobDirectory directory5 = directory4.GetSubdirectoryReference(delimiter);
Assert.AreEqual(directory5.Prefix, delimiter + delimiter);
CloudBlobDirectory directory6 = directory5.GetSubdirectoryReference(delimiter);
Assert.AreEqual(directory6.Prefix, delimiter + delimiter + delimiter);
CloudPageBlob blob2 = directory6.GetPageBlobReference("Blob1");
Assert.AreEqual(blob2.Name, delimiter + delimiter + delimiter + "Blob1");
Assert.AreEqual(blob2.Uri, blob.Uri);
}
finally
{
container.DeleteIfExists();
}
}
}
internal void DownloadBlobTestGB(Agent agent, StorageBlob.BlobType blobType)
{
string uploadFilePath = @".\" + Utility.GenNameString("gbupload");
string downloadFilePath = @".\" + Utility.GenNameString("gbdownload");
string containerName = Utility.GenNameString("gbupload-");
string blobName = Path.GetFileName(uploadFilePath);
// create the container
StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName);
// Generate a 512 bytes file which contains GB18030 characters
File.WriteAllText(uploadFilePath, GB18030String);
try
{
// create source blob
StorageBlob.ICloudBlob blob = CloudBlobUtil.GetBlob(container, blobName, blobType);
// upload file data
using (var fileStream = System.IO.File.OpenRead(uploadFilePath))
{
blob.UploadFromStream(fileStream);
}
//--------------Download operation--------------
Test.Assert(agent.GetAzureStorageBlobContent(blobName, downloadFilePath, containerName, true), "download blob should be successful");
// Check MD5
string localMd5 = Helper.GetFileContentMD5(downloadFilePath);
string uploadMd5 = Helper.GetFileContentMD5(uploadFilePath);
blob.FetchAttributes();
Test.Assert(localMd5 == uploadMd5, string.Format("blob content md5 should be {0}, and actualy it's {1}", localMd5, uploadMd5));
}
finally
{
// cleanup
container.DeleteIfExists();
File.Delete(uploadFilePath);
File.Delete(downloadFilePath);
}
}
/// <summary>
/// Create a container and then get it using powershell cmdlet
/// </summary>
/// <returns>A CloudBlobContainer object which is returned by PowerShell</returns>
protected StorageBlob.CloudBlobContainer CreateAndPsGetARandomContainer()
{
string containerName = Utility.GenNameString("bvt");
StorageBlob.CloudBlobContainer container = SetUpStorageAccount.CreateCloudBlobClient().GetContainerReference(containerName);
container.CreateIfNotExists();
try
{
PowerShellAgent agent = new PowerShellAgent();
Test.Assert(agent.GetAzureStorageContainer(containerName), Utility.GenComparisonData("GetAzureStorageContainer", true));
int count = 1;
Test.Assert(agent.Output.Count == count, string.Format("get container should return only 1 container, actully it's {0}", agent.Output.Count));
return((StorageBlob.CloudBlobContainer)agent.Output[0]["CloudBlobContainer"]);
}
finally
{
// clean up
container.DeleteIfExists();
}
}
public void CloudBlobDirectoryBlobParentValidate()
{
foreach (String delimiter in Delimiters)
{
CloudBlobClient client = GenerateCloudBlobClient();
client.DefaultDelimiter = delimiter;
string name = GetRandomContainerName();
CloudBlobContainer container = client.GetContainerReference(name);
try
{
CloudBlockBlob blob = container.GetBlockBlobReference("TopDir1" + delimiter + "MidDir1" + delimiter + "EndDir1" + delimiter + "EndBlob1");
CloudBlobDirectory directory = blob.Parent;
Assert.AreEqual(directory.Prefix, "TopDir1" + delimiter + "MidDir1" + delimiter + "EndDir1" + delimiter);
Assert.AreEqual(directory.Uri, container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter + "EndDir1" + delimiter);
}
finally
{
container.DeleteIfExists();
}
}
}
public void BlobReadWhenOpenWrite()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
MemoryStream memoryStream = new MemoryStream(buffer);
Stream blobStream = blob.OpenWrite(2048);
blobStream.Write(buffer, 0, 2048);
byte[] testBuffer = new byte[2048];
TestHelper.ExpectedException <NotSupportedException>(() => blobStream.Read(testBuffer, 0, 2048),
"Try reading from a stream opened for Write");
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobDirectoryGetParentOnRoot()
{
foreach (String delimiter in Delimiters)
{
CloudBlobClient client = GenerateCloudBlobClient();
client.DefaultDelimiter = delimiter;
string name = GetRandomContainerName();
CloudBlobContainer container = client.GetContainerReference(name);
try
{
CloudBlobDirectory root = container.GetDirectoryReference("TopDir1" + delimiter);
CloudBlobDirectory parent = root.Parent;
Assert.IsNull(parent);
}
finally
{
container.DeleteIfExists();
}
}
}
public void BlockBlobWriteStreamSeekTest()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudBlockBlob blob = container.GetBlockBlobReference("blob1");
using (Stream blobStream = blob.OpenWrite())
{
TestHelper.ExpectedException <NotSupportedException>(
() => blobStream.Seek(1, SeekOrigin.Begin),
"Block blob write stream should not be seekable");
}
}
finally
{
container.DeleteIfExists();
}
}
/// <summary>
/// Parameters:
/// Block:
/// True for BlockBlob, false for PageBlob
/// </summary>
internal void RemoveBlobTest(Agent agent, string UploadFilePath, Microsoft.WindowsAzure.Storage.Blob.BlobType Type)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("upload-");
string blobName = Path.GetFileName(UploadFilePath);
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >();
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Blob, blobName);
dic["BlobType"] = Type;
comp.Add(dic);
// create the container
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
try
{
bool bSuccess = false;
// upload the blob file
if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.BlockBlob)
{
bSuccess = CommonBlobHelper.UploadFileToBlockBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
else if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.PageBlob)
{
bSuccess = CommonBlobHelper.UploadFileToPageBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
Test.Assert(bSuccess, "upload file {0} to container {1} should succeed", UploadFilePath, NEW_CONTAINER_NAME);
//--------------Remove operation--------------
Test.Assert(agent.RemoveAzureStorageBlob(blobName, NEW_CONTAINER_NAME), Utility.GenComparisonData("RemoveAzureStorageBlob", true));
StorageBlob.ICloudBlob blob = CommonBlobHelper.QueryBlob(NEW_CONTAINER_NAME, blobName);
Test.Assert(blob == null, "blob {0} should not exist!", blobName);
}
finally
{
// cleanup
container.DeleteIfExists();
}
}