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)); }