public void Should_return_conflict_status_when_the_container_exists_and_is_not_empty()
{
try
{
using (new TestHelper(authToken, storageUrl))
{
var putStorageItem = new PutStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, Constants.StorageItemName);
var putStorageItemResponse= new GenerateRequestByType().Submit(putStorageItem, authToken);
Assert.That(putStorageItemResponse.Status, Is.EqualTo(HttpStatusCode.Created));
}
Assert.Fail("409 conflict expected");
}
catch (WebException we)
{
var response = (HttpWebResponse)we.Response;
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Conflict));
}
finally
{
var genrequest = new GenerateRequestByType();
genrequest.Submit( new DeleteStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName),authToken);
genrequest.Submit(new DeleteContainer(storageUrl, Constants.CONTAINER_NAME), authToken);
}
}
public void Should_return_no_content_when_the_container_exists()
{
PutContainer(storageUrl, Constants.CONTAINER_NAME);
var deleteContainer = new DeleteContainer(storageUrl, Constants.CONTAINER_NAME);
var response = new GenerateRequestByType().Submit(deleteContainer, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.NoContent));
}
public void Should_get_200_OK_or_204_No_Content_when_item_exists()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
try
{
testHelper.PutItemInContainer(Constants.HeadStorageItemName);
testHelper.AddMetadataToItem(Constants.HeadStorageItemName);
var getStorageItemInformation = new GetStorageItemInformation(storageUrl, Constants.CONTAINER_NAME, Constants.HeadStorageItemName);
var getStorageItemInformationResponse = new GenerateRequestByType().Submit(
getStorageItemInformation, authToken);
Assert.That(getStorageItemInformationResponse.Status == HttpStatusCode.OK
|| getStorageItemInformationResponse.Status == HttpStatusCode.NoContent, Is.True);
var metadata = getStorageItemInformationResponse.Metadata;
Assert.That(metadata["Test"], Is.EqualTo("test"));
Assert.That(metadata["Test2"], Is.EqualTo("test2"));
}
finally
{
testHelper.DeleteItemFromContainer(Constants.HeadStorageItemName);
}
}
}
public void should_be_able_to_return_stream_more_than_once()
{
ICloudFilesResponse getStorageItemResponse = null;
Stream stream = null;
Stream streamcopy = null;
try
{
connection.CreateContainer(Constants.CONTAINER_NAME);
connection.PutStorageItem(Constants.CONTAINER_NAME, Constants.StorageItemName);
var getStorageItem = new GetStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName);
getStorageItemResponse = new GenerateRequestByType().Submit(getStorageItem, authToken);
stream = getStorageItemResponse.GetResponseStream();
streamcopy = getStorageItemResponse.GetResponseStream();
Assert.AreEqual(stream.Length, streamcopy.Length);
Assert.Greater(getStorageItemResponse.ContentLength, 0);
Assert.IsTrue(stream.CanRead);
Assert.IsTrue(streamcopy.CanRead);
}
finally
{
if (getStorageItemResponse != null) getStorageItemResponse.Close();
if (stream != null) stream.Close();
if (streamcopy != null) streamcopy.Close();
connection.DeleteStorageItem(Constants.CONTAINER_NAME, Constants.StorageItemName);
connection.DeleteContainer(Constants.CONTAINER_NAME);
}
}
public void Should_return_created_status_when_the_container_does_not_exist()
{
CreateContainer createContainer = new CreateContainer(storageUrl, Constants.CONTAINER_NAME);
IResponse response = new GenerateRequestByType( ).Submit(createContainer, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
DeleteContainer(storageUrl, Constants.CONTAINER_NAME);
}
public void AddMetadataToItem(string storageItemName)
{
var metadata = new Dictionary<string, string> {{"Test", "test"}, {"Test2", "test2"}};
var setStorageItemMetaInformation = new CloudFiles.Domain.Request.SetStorageItemMetaInformation(storageUrl, containerName, storageItemName, metadata);
var postStorageItemResponse = new GenerateRequestByType().Submit(setStorageItemMetaInformation, authToken);
Assert.That(postStorageItemResponse.Status, Is.EqualTo(HttpStatusCode.Accepted));
Assert.That(Regex.Match(postStorageItemResponse.Headers["Content-Type"], "text/(plain|html)").Success, Is.True);
var contentLength = postStorageItemResponse.Headers["Content-Length"];
Assert.That(contentLength == "58" || contentLength == "0", Is.True);
}
public void Should_return_created_when_a_stream_is_passed_instead_of_a_file_name()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
var fs = new FileStream(Constants.StorageItemName, FileMode.Open, FileAccess.Read);
var putStorageItem = new PutStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, fs, null);
var response = new GenerateRequestByType().Submit(putStorageItem, authToken);
fs.Close();
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
testHelper.DeleteItemFromContainer();
}
}
public void Should_return_No_Content_status()
{
Assert.Ignore("Is returning OK instead of NoContent, need to investigate - 7/14/2010");
var request = new GetContainers(storageUrl);
var response = new GenerateRequestByType(
new RequestFactoryWithAgentSupport("NASTTestUserAgent")).Submit(request, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.NoContent));
if(response.ContentBody != null)
Assert.That(response.ContentBody.Count, Is.EqualTo(0));
response.Dispose();
}
public void Should_return_created_as_status_when_the_file_does_not_already_exist()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
var putStorageItem = new PutStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, Constants.StorageItemName);
// Assert.That(putStorageItem.ContentLength, Is.EqualTo(34)); //does not belong in this test
var response = new GenerateRequestByType().Submit(putStorageItem, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers[Constants.ETAG], Is.EqualTo(response.ETag));
testHelper.DeleteItemFromContainer();
}
}
public void should_return_204_no_content_when_the_item_exists()
{
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
testHelper.PutItemInContainer();
var deleteStorageItem = new DeleteStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName);
var response = new GenerateRequestByType().Submit(deleteStorageItem,authToken );
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.NoContent));
Console.WriteLine(response.Headers["Content-Type"]);
Assert.That(Regex.Match(response.Headers["Content-Type"], "text/(plain|html)").Success, Is.True);
}
}
public void Should_get_serialized_json_format()
{
var testHelper = new TestHelper(authToken, storageUrl);
testHelper.PutItemInContainer(Constants.StorageItemNameJpg);
var getContainerInformation = new GetContainerInformationSerialized(storageUrl, Constants.CONTAINER_NAME, Format.JSON);
var jsonResponse = new GenerateRequestByType().Submit(getContainerInformation, authToken);
Assert.That(jsonResponse.Status, Is.EqualTo(HttpStatusCode.OK));
var jsonReturnValue = String.Join("", jsonResponse.ContentBody.ToArray());
jsonResponse.Dispose();
var expectedSubString = "[{\"name\":[ ]?\"" + Constants.StorageItemNameJpg + "\",[ ]?\"hash\":[ ]?\"b44a59383b3123a747d139bd0e71d2df\",[ ]?\"bytes\":[ ]?\\d+,[ ]?\"content_type\":[ ]?\"image.*jpeg\",[ ]?\"last_modified\":[ ]?\"" + String.Format("{0:yyyy-MM}", DateTime.Now);
Assert.That(Regex.Match(jsonReturnValue, expectedSubString).Success, Is.True);
testHelper.DeleteItemFromContainer(Constants.StorageItemNameJpg);
testHelper.Dispose();
}
public void Should_get_serialized_xml_format()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
testHelper.PutItemInContainer(Constants.StorageItemNameJpg);
var getContainerInformation = new GetContainerInformationSerialized(storageUrl, Constants.CONTAINER_NAME, Format.XML);
var xmlResponse = new GenerateRequestByType().Submit(getContainerInformation, authToken);
Assert.That(xmlResponse.Status, Is.EqualTo(HttpStatusCode.OK));
var xmlReturnValue = String.Join("", xmlResponse.ContentBody.ToArray());
xmlResponse.Dispose();
var expectedSubString = "<container name=\"" + Constants.CONTAINER_NAME + "\"><object><name>" + Constants.StorageItemNameJpg + "<\\/name><hash>b44a59383b3123a747d139bd0e71d2df<\\/hash><bytes>\\d+<\\/bytes><content_type>image.*jpeg<\\/content_type><last_modified>" + String.Format("{0:yyyy-MM}", DateTime.Now);
Assert.That(Regex.Match(xmlReturnValue, expectedSubString).Success || string.IsNullOrEmpty(xmlReturnValue), Is.True);
testHelper.DeleteItemFromContainer(Constants.StorageItemNameJpg);
}
}
public void Should_return_accepted_when_meta_information_is_supplied()
{
using (TestHelper testHelper = new TestHelper(authToken, storageUrl))
{
testHelper.PutItemInContainer();
Dictionary<string, string> metadata = new Dictionary<string, string>();
metadata.Add("Test", "test");
metadata.Add("Test2", "test2");
SetStorageItemMetaInformation setStorageItemMetaInformation = new SetStorageItemMetaInformation(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, metadata);
var metaInformationResponse = new GenerateRequestByType().Submit(setStorageItemMetaInformation, authToken);
Assert.That(metaInformationResponse.Status, Is.EqualTo(HttpStatusCode.Accepted));
testHelper.DeleteItemFromContainer();
}
}
public void should_not_throw_an_exception_when_the_container_contains_utf8_characters_3()
{
var containerName = '\uDCFF' + "container" + new Guid();
try
{
connection.CreateContainer(containerName);
var getContainerItemList = new GetContainerItemList(storageUrl, containerName);
var response = new GenerateRequestByType().Submit(getContainerItemList, authToken);
response.Dispose();
Assert.That(true);
}
finally
{
connection.DeleteContainer(containerName);
}
}
public void Should_return_the_list_of_containers()
{
using (new TestHelper(authToken, storageUrl))
{
ICloudFilesResponse response = null;
try
{
GetContainers request = new GetContainers(storageUrl);
response = new GenerateRequestByType().Submit(request, authToken);
Assert.That(response.ContentBody.Count, Is.GreaterThan(0));
}
finally
{
if (response != null)
response.Dispose();
}
}
}
public void Should_return_ok_if_the_item_exists()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
ICloudFilesResponse getStorageItemResponse = null;
try
{
testHelper.PutItemInContainer();
var getStorageItem = new GetStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, requestHeaderFields);
getStorageItemResponse = new GenerateRequestByType().Submit(getStorageItem, authToken);
Assert.That(getStorageItemResponse.Status, Is.EqualTo(HttpStatusCode.OK));
}
finally
{
if (getStorageItemResponse != null) getStorageItemResponse.Dispose();
testHelper.DeleteItemFromContainer();
}
}
}
public void Should_throw_an_exception_when_the_container_name_exceeds_the_maximum_length()
{
string containerName = new string('a', Constants.MaximumContainerNameLength + 1);
try
{
using (new TestHelper(authToken, storageUrl, containerName))
{
var putStorageItem = new PutStorageItem(storageUrl, containerName, Constants.StorageItemName, Constants.StorageItemName);
// Assert.That(putStorageItem.ContentLength, Is.GreaterThan(0));
var putStorageItemResponse = new GenerateRequestByType().Submit(putStorageItem, authToken);
Assert.That(putStorageItemResponse.Status, Is.EqualTo(HttpStatusCode.Created));
}
Assert.Fail("ContainerNameException expected");
}
catch (Exception ex)
{
Assert.That(ex, Is.TypeOf(typeof (ContainerNameException)));
}
}
public void Should_return_OK_status()
{
using(new TestHelper(authToken, storageUrl))
{
ICloudFilesResponse response = null;
try
{
GetContainers request = new GetContainers(storageUrl);
response = new GenerateRequestByType(new RequestFactoryWithAgentSupport("NASTTestUserAgent")).Submit(request, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.OK));
Assert.That(response.ContentBody, Is.Not.Null);
}
finally
{
if(response != null)
response.Dispose();
}
}
}
public void SetUpBase()
{
var uri = new Uri(Constants.AUTH_URL);
var request =
new GetAuthentication(
new UserCredentials(
uri,
Constants.CREDENTIALS_USER_NAME,
Constants.CREDENTIALS_PASSWORD,
Constants.CREDENTIALS_CLOUD_VERSION,
Constants.CREDENTIALS_ACCOUNT_NAME));
var response = new GenerateRequestByType().Submit(request, authToken);
;
storageUrl = response.Headers[CloudFiles.Utils.Constants.X_STORAGE_URL];
authToken = response.Headers[CloudFiles.Utils.Constants.X_AUTH_TOKEN];
Assert.That(authToken.Length, Is.EqualTo(32));
SetUp();
}
public void should_return_number_of_containers_and_bytes_used()
{
try
{
connection.CreateContainer(Constants.CONTAINER_NAME);
connection.PutStorageItem(Constants.CONTAINER_NAME, Constants.StorageItemName);
}
finally
{
connection.DeleteStorageItem(Constants.CONTAINER_NAME, Constants.StorageItemName);
connection.DeleteContainer(Constants.CONTAINER_NAME);
}
using (var testHelper = new TestHelper(authToken, storageUrl))
{
testHelper.PutItemInContainer(Constants.StorageItemName, Constants.StorageItemName);
var getAccountInformation = new GetAccountInformation(storageUrl);
var response =new GenerateRequestByType().Submit(getAccountInformation, authToken);
Assert.That(response.Headers[Constants.XAccountBytesUsed], Is.Not.Null);
Assert.That(response.Headers[Constants.XAccountContainerCount], Is.Not.Null);
testHelper.DeleteItemFromContainer(Constants.StorageItemName);
}
}
public void Should_return_item_if_the_item_exists_and_has_been_modified_since_designated_time()
{
requestHeaderFields = new Dictionary<RequestHeaderFields, string>
{{RequestHeaderFields.IfModifiedSince, pastDateTime.ToString()}};
using (var testHelper = new TestHelper(authToken, storageUrl))
{
ICloudFilesResponse getStorageItemResponse = null;
try
{
testHelper.PutItemInContainer();
var getStorageItem = new GetStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, requestHeaderFields);
getStorageItemResponse = new GenerateRequestByType().Submit(getStorageItem, authToken);
Assert.That(getStorageItemResponse.Status, Is.EqualTo(HttpStatusCode.OK));
}
finally
{
if (getStorageItemResponse != null) getStorageItemResponse.Dispose();
testHelper.DeleteItemFromContainer();
}
}
}
public void should_return_account_information_in_json_format_including_name_count_and_bytes()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
try
{
testHelper.PutItemInContainer(Constants.StorageItemName);
var getAccountInformationJson = new GetAccountInformationSerialized(storageUrl, Format.JSON);
var getAccountInformationJsonResponse = new GenerateRequestByType().Submit(getAccountInformationJson, authToken);
if(getAccountInformationJsonResponse.ContentBody.Count == 0)
Assert.Fail("No content body returned in response");
const string expectedSubString = "{\"name\":[ ]?\"" + Constants.CONTAINER_NAME + "\",[ ]?\"count\":[ ]?\\d+,[ ]?\"bytes\":[ ]?\\d+}";
var contentBody = getAccountInformationJsonResponse.ContentBody;
getAccountInformationJsonResponse.Dispose();
foreach (var s in contentBody)
{
if (Regex.Match(s, expectedSubString).Success) return;
}
Assert.Fail("Expected value: " + expectedSubString + " not found");
}
finally
{
testHelper.DeleteItemFromContainer();
}
}
}
public void should_return_204_no_content_when_the_account_has_no_containers()
{
var getAccountInformation = new GetAccountInformation(storageUrl);
var response = new GenerateRequestByType().Submit(getAccountInformation, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.NoContent));
}
public void should_return_account_name_and_ok_status_200()
{
var accountInformationXml = new GetAccountInformationSerialized(storageUrl, Format.XML);
var getAccountInformationXmlResponse =new GenerateRequestByType().Submit(accountInformationXml, authToken);
Assert.That(getAccountInformationXmlResponse.Status, Is.EqualTo(HttpStatusCode.OK));
var contentBody = "";
foreach (var s in getAccountInformationXmlResponse.ContentBody)
{
contentBody += s;
}
getAccountInformationXmlResponse.Dispose();
const string expectedSubString = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><account name=\"MossoCloudFS_5d8f3dca-7eb9-4453-aa79-2eea1b980353\"></account>";
Assert.That(contentBody, Is.EqualTo(expectedSubString));
}
public void should_return_account_information_in_xml_format_including_name_count_and_size()
{
using (var testHelper = new TestHelper(authToken, storageUrl))
{
try
{
testHelper.PutItemInContainer(Constants.StorageItemName);
var accountInformationXml = new GetAccountInformationSerialized(storageUrl, Format.XML);
var getAccountInformationXmlResponse = new GenerateRequestByType().Submit(accountInformationXml,authToken);
if (getAccountInformationXmlResponse.ContentBody.Count == 0)
Assert.Ignore("No content body returned in response");
var contentBody = "";
foreach (var s in getAccountInformationXmlResponse.ContentBody)
{
contentBody += s;
}
getAccountInformationXmlResponse.Dispose();
var xmlDocument = new XmlDocument();
try
{
xmlDocument.LoadXml(contentBody);
}
catch(XmlException e)
{
Console.WriteLine(e.Message);
}
const string expectedSubString = "<container><name>"+ Constants.CONTAINER_NAME +"</name><count>\\d*</count><bytes>\\d+</bytes></container>";
Assert.That(Regex.Match(contentBody, expectedSubString).Success, Is.True);
}
finally
{
testHelper.DeleteItemFromContainer();
}
}
}
public void should_return_empty_brackets_and_ok_status_200()
{
var getAccountInformationJson = new GetAccountInformationSerialized(storageUrl, Format.JSON);
var getAccountInformationJsonResponse = new GenerateRequestByType().Submit(getAccountInformationJson, authToken);
Assert.That(getAccountInformationJsonResponse.Status, Is.EqualTo(HttpStatusCode.OK));
var contentBody = String.Join("",getAccountInformationJsonResponse.ContentBody.ToArray());
getAccountInformationJsonResponse.Dispose();
Assert.That(contentBody, Is.EqualTo("[]"));
}
public void Should_return_no_content_when_the_container_exists_and_the_name_contains_spaces()
{
const string containerName = "I am making a funky container";
using(var testHelper = new TestHelper(authToken, storageUrl, containerName))
{
testHelper.PutItemInContainer(Constants.StorageItemName, Constants.StorageItemName);
var getContainerInformation = new GetContainerInformation(storageUrl, containerName);
var informationResponse = new GenerateRequestByType().Submit(getContainerInformation, authToken);
Assert.That(informationResponse.Status, Is.EqualTo(HttpStatusCode.NoContent));
Assert.That(informationResponse.Headers[Constants.XContainerObjectCount], Is.EqualTo("1"));
Assert.That(informationResponse.Headers[Constants.XContainerBytesUsed], (Is.Not.Null));
testHelper.DeleteItemFromContainer(Constants.StorageItemName);
}
}
private void CreateContainer()
{
var createContainer = new CloudFiles.Domain.Request.CreateContainer(storageUrl, containerName);
var putContainerResponse = new GenerateRequestByType().Submit(createContainer, authToken);
Assert.That(putContainerResponse.Status, Is.EqualTo(HttpStatusCode.Created));
}
public void PutItemInContainer(string storageItemName, string remoteName)
{
var putStorageItem = new CloudFiles.Domain.Request.PutStorageItem(storageUrl, containerName, remoteName, storageItemName);
var putStorageItemResponse = new GenerateRequestByType().Submit(putStorageItem, authToken);
Assert.That(putStorageItemResponse.Status, Is.EqualTo(HttpStatusCode.Created));
}
public void DeleteItemFromContainer(string storageItemName)
{
var deleteStorageItem = new CloudFiles.Domain.Request.DeleteStorageItem(storageUrl, containerName, storageItemName);
var deleteStorageItemResponse = new GenerateRequestByType().Submit(deleteStorageItem, authToken);
Assert.That(deleteStorageItemResponse.Status, Is.EqualTo(HttpStatusCode.NoContent));
}