public static async Task <StorageExtendedErrorInformation> ReadFromStreamAsync(Stream inputStream, CancellationToken cancellationToken) { CommonUtility.AssertNotNull("inputStream", inputStream); if (inputStream.CanSeek && inputStream.Length < 1) { return(null); } try { using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(inputStream)) { await reader.ReadAsync().ConfigureAwait(continueOnCapturedContext: false); cancellationToken.ThrowIfCancellationRequested(); StorageExtendedErrorInformation result = await ReadXmlAsync(reader, cancellationToken).ConfigureAwait(continueOnCapturedContext: false); cancellationToken.ThrowIfCancellationRequested(); return(result); } } catch (XmlException) { return(null); } }
/// <summary> /// Parses the XML response for an operation to get a range for a file. /// </summary> /// <returns>An enumerable collection of <see cref="FileRange"/> objects.</returns> internal static async Task <IEnumerable <FileRange> > ParseAsync(Stream stream, CancellationToken token) { using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(stream)) { token.ThrowIfCancellationRequested(); List <FileRange> ranges = new List <FileRange>(); if (await reader.ReadToFollowingAsync(Constants.FileRangeListElement).ConfigureAwait(false)) { if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { await reader.ReadStartElementAsync().ConfigureAwait(false); while (await reader.IsStartElementAsync(Constants.FileRangeElement).ConfigureAwait(false)) { ranges.Add(await ParseRangeAsync(reader, token).ConfigureAwait(false)); } await reader.ReadEndElementAsync().ConfigureAwait(false); } } return(ranges); } }
/// <summary> /// Gets the error details from an XML-formatted error stream. /// </summary> /// <param name="inputStream">The input stream.</param> /// <returns>The error details.</returns> public static async Task <StorageExtendedErrorInformation> ReadFromStreamAsync(Stream inputStream) { CommonUtility.AssertNotNull("inputStream", inputStream); if (inputStream.CanSeek && inputStream.Length < 1) { return(null); } StorageExtendedErrorInformation extendedErrorInfo = new StorageExtendedErrorInformation(); try { using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(inputStream)) { await reader.ReadAsync().ConfigureAwait(false); await extendedErrorInfo.ReadXmlAsync(reader, CancellationToken.None).ConfigureAwait(false); } return(extendedErrorInfo); } catch (XmlException) { // If there is a parsing error we cannot return extended error information return(null); } }
public async Task ExtendedErrorInfoVerifyXmlWithAdditionalDetails() { Uri baseAddressUri = new Uri(TestBase.TargetTenantConfig.BlobServiceEndpoint); CloudBlobClient client = new CloudBlobClient(baseAddressUri, TestBase.StorageCredentials); CloudBlobContainer container = client.GetContainerReference(Guid.NewGuid().ToString("N")); byte[] buffer = TestBase.GetRandomBuffer(4 * 1024 * 1024); MD5 md5 = MD5.Create(); string contentMD5 = Convert.ToBase64String(md5.ComputeHash(buffer)); try { container.Create(); CloudBlockBlob blob = container.GetBlockBlobReference("blob1"); List <string> blocks = new List <string>(); for (int i = 0; i < 2; i++) { blocks.Add(Convert.ToBase64String(Guid.NewGuid().ToByteArray())); } using (MemoryStream memoryStream = new MemoryStream(buffer)) { memoryStream.Seek(0, SeekOrigin.Begin); blob.PutBlock(blocks[0], memoryStream, contentMD5); int offset = buffer.Length - 1024; memoryStream.Seek(offset, SeekOrigin.Begin); StorageException e = TestHelper.ExpectedException <StorageException>( () => blob.PutBlock(blocks[1], memoryStream, contentMD5), "Invalid MD5 should fail with mismatch"); Assert.IsNotNull(e.RequestInformation.ExtendedErrorInformation); StorageExtendedErrorInformation retrErrorInfo = new StorageExtendedErrorInformation(); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; StringBuilder sb = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(sb, settings)) { e.RequestInformation.ExtendedErrorInformation.WriteXml(writer); } using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(sb.ToString())))) { await retrErrorInfo.ReadXmlAsync(reader, CancellationToken.None); } Assert.AreEqual(e.RequestInformation.ExtendedErrorInformation.ErrorCode, retrErrorInfo.ErrorCode); Assert.AreEqual(e.RequestInformation.ExtendedErrorInformation.ErrorMessage, retrErrorInfo.ErrorMessage); Assert.AreNotEqual(0, retrErrorInfo.AdditionalDetails.Count); Assert.AreEqual(e.RequestInformation.ExtendedErrorInformation.AdditionalDetails.Count, retrErrorInfo.AdditionalDetails.Count); } } finally { container.DeleteIfExists(); } }
public async Task QueueContinuationTokenVerifyXmlFunctions() { CloudQueueClient client = GenerateCloudQueueClient(); string prefix = "dotnetqueuetest" + Guid.NewGuid().ToString("N"); List <string> queueNames = new List <string>(); int count = 30; for (int i = 0; i < count; i++) { queueNames.Add(prefix + i); client.GetQueueReference(prefix + i).Create(); } QueueContinuationToken token = null; List <CloudQueue> results = new List <CloudQueue>(); do { QueueResultSegment segment = client.ListQueuesSegmented(prefix, QueueListingDetails.None, 5, token, null, null); token = segment.ContinuationToken; results.AddRange(segment.Results); 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)) { token.WriteXml(writer); } using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(sb.ToString())))) { token = new QueueContinuationToken(); await token.ReadXmlAsync(reader); } } }while (token != null); foreach (CloudQueue queue in results) { if (queueNames.Remove(queue.Name)) { queue.Delete(); } else { Assert.Fail(); } } Assert.AreEqual <int>(0, queueNames.Count); }
/// <summary> /// Parses the XML response returned by an operation to get messages from a queue. /// </summary> /// <returns>An enumerable collection of <see cref="QueueMessage"/> objects.</returns> internal static async Task <IEnumerable <QueueMessage> > ParseAsync(Stream stream, CancellationToken token) { using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(stream)) { token.ThrowIfCancellationRequested(); List <QueueMessage> messages = new List <QueueMessage>(); if (await reader.ReadToFollowingAsync(Constants.MessagesElement).ConfigureAwait(false)) { if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { await reader.ReadStartElementAsync().ConfigureAwait(false); while (await reader.IsStartElementAsync().ConfigureAwait(false)) { token.ThrowIfCancellationRequested(); if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { switch (reader.Name) { case Constants.MessageElement: while (await reader.IsStartElementAsync().ConfigureAwait(false)) { messages.Add(await ParseMessageEntryAsync(reader, token).ConfigureAwait(false)); } break; default: await reader.SkipAsync().ConfigureAwait(false); break; } } } await reader.ReadEndElementAsync().ConfigureAwait(false); } } return(messages); } }
public async Task QueueContinuationTokenVerifyEmptyTargetDeserializer() { QueueContinuationToken queueContinuationToken = new QueueContinuationToken { TargetLocation = null }; StringBuilder stringBuilder = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(stringBuilder)) { queueContinuationToken.WriteXml(writer); } string stringToken = stringBuilder.ToString(); QueueContinuationToken parsedToken = new QueueContinuationToken(); await parsedToken.ReadXmlAsync(XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(stringToken)))); Assert.AreEqual(parsedToken.TargetLocation, null); }
internal static async Task <UserDelegationKey> ParseAsync(Stream stream, CancellationToken token) { UserDelegationKey key = null; using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(stream)) { token.ThrowIfCancellationRequested(); if (await reader.ReadToFollowingAsync(Constants.UserDelegationKey).ConfigureAwait(false)) { if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { key = await ParseKey(reader, token); } } } return(key); }
public async Task ExtendedErrorInfoVerifyXml() { Uri baseAddressUri = new Uri(TestBase.TargetTenantConfig.BlobServiceEndpoint); CloudBlobClient client = new CloudBlobClient(baseAddressUri, TestBase.StorageCredentials); CloudBlobContainer container = client.GetContainerReference(Guid.NewGuid().ToString("N")); try { StorageException e = TestHelper.ExpectedException <StorageException>( () => container.GetPermissions(), "Try to get permissions on a non-existent container"); Assert.IsNotNull(e.RequestInformation.ExtendedErrorInformation); StorageExtendedErrorInformation retrErrorInfo = new StorageExtendedErrorInformation(); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; StringBuilder sb = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(sb, settings)) { e.RequestInformation.ExtendedErrorInformation.WriteXml(writer); } using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(sb.ToString())))) { await retrErrorInfo.ReadXmlAsync(reader, CancellationToken.None); } Assert.AreEqual(e.RequestInformation.ExtendedErrorInformation.ErrorCode, retrErrorInfo.ErrorCode); Assert.AreEqual(e.RequestInformation.ExtendedErrorInformation.ErrorMessage, retrErrorInfo.ErrorMessage); } finally { container.DeleteIfExists(); } }
/// <summary> /// Parses the response XML for a container listing operation. /// </summary> /// <returns>An enumerable collection of <see cref="BlobContainerEntry"/> objects.</returns> internal static async Task <ListContainersResponse> ParseAsync(Stream stream, CancellationToken token) { using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(stream)) { token.ThrowIfCancellationRequested(); List <BlobContainerEntry> entries = new List <BlobContainerEntry>(); string nextMarker = default(string); if (await reader.ReadToFollowingAsync(Constants.EnumerationResultsElement).ConfigureAwait(false)) { if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { Uri baseUri = new Uri(reader.GetAttribute(Constants.ServiceEndpointElement)); await reader.ReadStartElementAsync().ConfigureAwait(false); while (await reader.IsStartElementAsync().ConfigureAwait(false)) { token.ThrowIfCancellationRequested(); if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { switch (reader.Name) { case Constants.MarkerElement: await reader.ReadElementContentAsStringAsync().ConfigureAwait(false); break; case Constants.NextMarkerElement: nextMarker = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false); break; case Constants.MaxResultsElement: await reader.ReadElementContentAsInt32Async().ConfigureAwait(false); break; case Constants.PrefixElement: await reader.ReadElementContentAsStringAsync().ConfigureAwait(false); break; case Constants.ContainersElement: await reader.ReadStartElementAsync().ConfigureAwait(false); while (await reader.IsStartElementAsync(Constants.ContainerElement).ConfigureAwait(false)) { entries.Add(await ParseContainerEntryAsync(reader, baseUri, token).ConfigureAwait(false)); } await reader.ReadEndElementAsync().ConfigureAwait(false); break; default: await reader.SkipAsync().ConfigureAwait(false); break; } } } await reader.ReadEndElementAsync().ConfigureAwait(false); } } return(new ListContainersResponse { Containers = entries, NextMarker = nextMarker }); } }
/// <summary> /// Parses the response XML for a blob listing operation. /// </summary> /// <returns>An enumerable collection of objects that implement <see cref="IListBlobEntry"/>.</returns> internal static async Task <ListBlobsResponse> ParseAsync(Stream stream, CancellationToken token) { using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(stream)) { token.ThrowIfCancellationRequested(); List <IListBlobEntry> entries = new List <IListBlobEntry>(); string nextMarker = default(string); if (await reader.ReadToFollowingAsync(Constants.EnumerationResultsElement).ConfigureAwait(false)) { if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { Uri baseUri; string serviceEndpoint = reader.GetAttribute(Constants.ServiceEndpointElement); if (!string.IsNullOrEmpty(serviceEndpoint)) { baseUri = NavigationHelper.AppendPathToSingleUri( new Uri(serviceEndpoint), reader.GetAttribute(Constants.ContainerNameElement)); } else { baseUri = new Uri(reader.GetAttribute(Constants.ContainerNameElement)); } await reader.ReadStartElementAsync().ConfigureAwait(false); while (await reader.IsStartElementAsync().ConfigureAwait(false)) { token.ThrowIfCancellationRequested(); if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { switch (reader.Name) { case Constants.DelimiterElement: await reader.ReadElementContentAsStringAsync().ConfigureAwait(false); break; case Constants.MarkerElement: await reader.ReadElementContentAsStringAsync().ConfigureAwait(false); break; case Constants.NextMarkerElement: nextMarker = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false); break; case Constants.MaxResultsElement: await reader.ReadElementContentAsInt32Async().ConfigureAwait(false); break; case Constants.PrefixElement: await reader.ReadElementContentAsStringAsync().ConfigureAwait(false); break; case Constants.BlobsElement: await reader.ReadStartElementAsync().ConfigureAwait(false); while (await reader.IsStartElementAsync().ConfigureAwait(false)) { switch (reader.Name) { case Constants.BlobElement: entries.Add(await ParseBlobEntryAsync(reader, baseUri, token).ConfigureAwait(false)); break; case Constants.BlobPrefixElement: entries.Add(await ParseBlobPrefixEntryAsync(reader, token).ConfigureAwait(false)); break; } } await reader.ReadEndElementAsync().ConfigureAwait(false); break; default: await reader.SkipAsync().ConfigureAwait(false); break; } } } await reader.ReadEndElementAsync().ConfigureAwait(false); } } return(new ListBlobsResponse { Blobs = entries, NextMarker = nextMarker }); } }
public async Task RequestResultErrorCode() { Uri baseAddressUri = new Uri(TestBase.TargetTenantConfig.BlobServiceEndpoint); CloudBlobClient client = new CloudBlobClient(baseAddressUri, TestBase.StorageCredentials); CloudBlobContainer container = client.GetContainerReference(Guid.NewGuid().ToString("N")); byte[] buffer = TestBase.GetRandomBuffer(4 * 1024 * 1024); MD5 md5 = MD5.Create(); string contentMD5 = Convert.ToBase64String(md5.ComputeHash(buffer)); try { RequestResult requestResult; XmlWriterSettings settings; StringBuilder sb; container.Create(); CloudBlockBlob blob = container.GetBlockBlobReference("blob1"); List <string> blocks = new List <string>(); for (int i = 0; i < 2; i++) { blocks.Add(Convert.ToBase64String(Guid.NewGuid().ToByteArray())); } // Verify the ErrorCode property is set and that it is serialized correctly using (MemoryStream memoryStream = new MemoryStream(buffer)) { memoryStream.Seek(0, SeekOrigin.Begin); blob.PutBlock(blocks[0], memoryStream, contentMD5); int offset = buffer.Length - 1024; memoryStream.Seek(offset, SeekOrigin.Begin); StorageException e = TestHelper.ExpectedException <StorageException>( () => blob.PutBlock(blocks[1], memoryStream, contentMD5), "Invalid MD5 should fail with mismatch"); Assert.AreEqual(e.RequestInformation.ErrorCode, StorageErrorCodeStrings.Md5Mismatch); requestResult = new RequestResult(); settings = new XmlWriterSettings(); settings.Indent = true; sb = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(sb, settings)) { e.RequestInformation.WriteXml(writer); } using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(sb.ToString())))) { await requestResult.ReadXmlAsync(reader); } // ExtendedErrorInformation.ErrorCode will be depricated, but it should still match on a non HEAD request Assert.AreEqual(e.RequestInformation.ErrorCode, requestResult.ErrorCode); Assert.AreEqual(e.RequestInformation.ExtendedErrorInformation.ErrorCode, requestResult.ErrorCode); } // Verify the ErrorCode property is set on a HEAD request CloudAppendBlob blob2 = container.GetAppendBlobReference("blob2"); blob2.CreateOrReplace(); StorageException e2 = TestHelper.ExpectedException <StorageException>( () => blob2.FetchAttributes(AccessCondition.GenerateIfMatchCondition("\"garbage\"")), // must supply our own quotes for a valid etag "Mismatched etag should fail"); Assert.AreEqual(e2.RequestInformation.ErrorCode, StorageErrorCodeStrings.ConditionNotMet); // Verify the ErrorCode property is not set on a successful request and that it is serialized correctly OperationContext ctx = new OperationContext(); blob2.FetchAttributes(operationContext: ctx); Assert.AreEqual(ctx.RequestResults[0].ErrorCode, null); requestResult = new RequestResult(); settings = new XmlWriterSettings(); settings.Indent = true; sb = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(sb, settings)) { ctx.RequestResults[0].WriteXml(writer); } using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(sb.ToString())))) { await requestResult.ReadXmlAsync(reader); } Assert.AreEqual(ctx.RequestResults[0].ErrorCode, requestResult.ErrorCode); } finally { container.DeleteIfExists(); } }
public async Task QueueContinuationTokenVerifySerializer() { XmlSerializer serializer = new XmlSerializer(typeof(QueueContinuationToken)); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; StringReader reader; string tokenxml; QueueContinuationToken writeToken = new QueueContinuationToken { NextMarker = Guid.NewGuid().ToString(), TargetLocation = StorageLocation.Primary }; QueueContinuationToken readToken = null; // Write with XmlSerializer using (StringWriter writer = new StringWriter()) { serializer.Serialize(writer, writeToken); tokenxml = writer.ToString(); } // Read with XmlSerializer reader = new StringReader(tokenxml); readToken = (QueueContinuationToken)serializer.Deserialize(reader); Assert.AreEqual(writeToken.NextMarker, readToken.NextMarker); // Read with token.ReadXml() using (XmlReader xmlReader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(tokenxml)))) { readToken = new QueueContinuationToken(); await readToken.ReadXmlAsync(xmlReader); } Assert.AreEqual(writeToken.NextMarker, readToken.NextMarker); // Read with token.ReadXml() using (XmlReader xmlReader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(tokenxml)))) { readToken = new QueueContinuationToken(); await readToken.ReadXmlAsync(xmlReader); } // Write with token.WriteXml StringBuilder sb = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(sb, settings)) { writeToken.WriteXml(writer); } // Read with XmlSerializer reader = new StringReader(sb.ToString()); readToken = (QueueContinuationToken)serializer.Deserialize(reader); Assert.AreEqual(writeToken.NextMarker, readToken.NextMarker); // Read with token.ReadXml() using (XmlReader xmlReader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(sb.ToString())))) { readToken = new QueueContinuationToken(); await readToken.ReadXmlAsync(xmlReader); } Assert.AreEqual(writeToken.NextMarker, readToken.NextMarker); }
/// <summary> /// Parses the response XML for a file listing operation. /// </summary> /// <returns>An enumerable collection of objects that implement <see cref="IListFileEntry"/>.</returns> internal static async Task <ListFilesAndDirectoriesResponse> ParseAsync(Stream stream, CancellationToken token) { using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(stream)) { token.ThrowIfCancellationRequested(); List <IListFileEntry> entries = new List <IListFileEntry>(); string nextMarker = default(string); if (await reader.ReadToFollowingAsync(Constants.EnumerationResultsElement).ConfigureAwait(false)) { if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { Uri baseUri = new Uri(reader.GetAttribute(Constants.ServiceEndpointElement)); baseUri = NavigationHelper.AppendPathToSingleUri(baseUri, reader.GetAttribute(Constants.ShareNameElement)); baseUri = NavigationHelper.AppendPathToSingleUri(baseUri, reader.GetAttribute(Constants.DirectoryPathElement)); await reader.ReadStartElementAsync().ConfigureAwait(false); while (await reader.IsStartElementAsync().ConfigureAwait(false)) { token.ThrowIfCancellationRequested(); if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { switch (reader.Name) { case Constants.MarkerElement: await reader.ReadElementContentAsStringAsync().ConfigureAwait(false); break; case Constants.NextMarkerElement: nextMarker = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false); break; case Constants.MaxResultsElement: await reader.ReadElementContentAsInt32Async().ConfigureAwait(false); break; case Constants.EntriesElement: await reader.ReadStartElementAsync().ConfigureAwait(false); while (await reader.IsStartElementAsync().ConfigureAwait(false)) { switch (reader.Name) { case Constants.FileElement: entries.Add(await ParseFileEntryAsync(reader, baseUri, token).ConfigureAwait(false)); break; case Constants.FileDirectoryElement: entries.Add(await ParseFileDirectoryEntryAsync(reader, baseUri, token).ConfigureAwait(false)); break; } } await reader.ReadEndElementAsync().ConfigureAwait(false); break; default: await reader.SkipAsync().ConfigureAwait(false); break; } } } await reader.ReadEndElementAsync().ConfigureAwait(false); } } return(new ListFilesAndDirectoriesResponse { Files = entries, NextMarker = nextMarker }); } }
/// <summary> /// Initializes a new instance of the AccessPolicyResponseBase class. /// </summary> /// <param name="stream">The stream to be parsed.</param> protected AccessPolicyResponseBase(Stream stream) { this.reader = XMLReaderExtensions.CreateAsAsync(stream); this.AccessIdentifiers = this.ParseAsync(); }
/// <summary> /// Asynchronously parses the XML response returned by an operation to retrieve a list of blocks. /// </summary> /// <param name="stream">The stream containing the XML response.</param> /// <param name="token">The cancellation token.</param> /// <returns>The list of <see cref="ListBlockItem"/> objects.</returns> internal static async Task <IEnumerable <ListBlockItem> > ParseAsync(Stream stream, CancellationToken token) { token.ThrowIfCancellationRequested(); List <ListBlockItem> blocks = new List <ListBlockItem>(); using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(stream)) { token.ThrowIfCancellationRequested(); if (await reader.ReadToFollowingAsync(Constants.BlockListElement).ConfigureAwait(false)) { if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { await reader.ReadStartElementAsync().ConfigureAwait(false); while (await reader.IsStartElementAsync().ConfigureAwait(false)) { token.ThrowIfCancellationRequested(); if (reader.IsEmptyElement) { await reader.SkipAsync().ConfigureAwait(false); } else { switch (reader.Name) { case Constants.CommittedBlocksElement: await reader.ReadStartElementAsync().ConfigureAwait(false); while (await reader.IsStartElementAsync(Constants.BlockElement).ConfigureAwait(false)) { token.ThrowIfCancellationRequested(); blocks.Add(await ParseBlockItemAsync(true, reader, token).ConfigureAwait(false)); } await reader.ReadEndElementAsync().ConfigureAwait(false); break; case Constants.UncommittedBlocksElement: await reader.ReadStartElementAsync().ConfigureAwait(false); while (await reader.IsStartElementAsync(Constants.BlockElement).ConfigureAwait(false)) { token.ThrowIfCancellationRequested(); blocks.Add(await ParseBlockItemAsync(false, reader, token).ConfigureAwait(false)); } await reader.ReadEndElementAsync().ConfigureAwait(false); break; default: await reader.SkipAsync().ConfigureAwait(false); break; } } } await reader.ReadEndElementAsync().ConfigureAwait(false); } } return(blocks); } }
public async Task RequestResultVerifyXml() { Uri baseAddressUri = new Uri(TestBase.TargetTenantConfig.BlobServiceEndpoint); CloudBlobClient blobClient = new CloudBlobClient(baseAddressUri, TestBase.StorageCredentials); CloudBlobContainer container = blobClient.GetContainerReference(Guid.NewGuid().ToString("N")); OperationContext opContext = new OperationContext(); Assert.IsNull(opContext.LastResult); container.Exists(null, opContext); Assert.IsNotNull(opContext.LastResult); // 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 = opContext.LastResult.StartTime; start = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, start.Second); DateTime end = opContext.LastResult.EndTime; end = new DateTime(end.Year, end.Month, end.Day, end.Hour, end.Minute, end.Second); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; StringBuilder sb = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(sb, settings)) { opContext.LastResult.WriteXml(writer); } RequestResult retrResult = new RequestResult(); using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(sb.ToString())))) { await retrResult.ReadXmlAsync(reader); } Assert.AreEqual(opContext.LastResult.RequestDate, retrResult.RequestDate); Assert.AreEqual(opContext.LastResult.ServiceRequestID, retrResult.ServiceRequestID); Assert.AreEqual(start, retrResult.StartTime); Assert.AreEqual(end, retrResult.EndTime); Assert.AreEqual(opContext.LastResult.HttpStatusCode, retrResult.HttpStatusCode); Assert.AreEqual(opContext.LastResult.HttpStatusMessage, retrResult.HttpStatusMessage); Assert.AreEqual(opContext.LastResult.ContentMd5, retrResult.ContentMd5); Assert.AreEqual(opContext.LastResult.Etag, retrResult.Etag); // Now test with no indentation sb = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(sb)) { opContext.LastResult.WriteXml(writer); } retrResult = new RequestResult(); using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(sb.ToString())))) { await retrResult.ReadXmlAsync(reader); } Assert.AreEqual(opContext.LastResult.RequestDate, retrResult.RequestDate); Assert.AreEqual(opContext.LastResult.ServiceRequestID, retrResult.ServiceRequestID); Assert.AreEqual(start, retrResult.StartTime); Assert.AreEqual(end, retrResult.EndTime); Assert.AreEqual(opContext.LastResult.HttpStatusCode, retrResult.HttpStatusCode); Assert.AreEqual(opContext.LastResult.HttpStatusMessage, retrResult.HttpStatusMessage); Assert.AreEqual(opContext.LastResult.ContentMd5, retrResult.ContentMd5); Assert.AreEqual(opContext.LastResult.Etag, retrResult.Etag); }