public async Task ParseBatchResponse()
{
var stream = MakeStream(BlobBatchResponse);
var responses = await Multipart.ParseAsync(stream, ContentType, true, default);
Assert.That(responses, Is.Not.Null);
Assert.That(responses.Length, Is.EqualTo(3));
var response = responses[0];
Assert.That(response.Status, Is.EqualTo((int)HttpStatusCode.Accepted));
Assert.That(response.TryGetHeader("x-ms-version", out var version));
Assert.That(version, Is.EqualTo("2018-11-09"));
Assert.That(response.TryGetHeader("x-ms-request-id", out _));
response = responses[1];
Assert.That(response.Status, Is.EqualTo((int)HttpStatusCode.Accepted));
Assert.That(response.TryGetHeader("x-ms-version", out version));
Assert.That(version, Is.EqualTo("2018-11-09"));
Assert.That(response.TryGetHeader("x-ms-request-id", out _));
response = responses[2];
Assert.That(response.Status, Is.EqualTo((int)HttpStatusCode.NotFound));
Assert.That(response.TryGetHeader("x-ms-version", out version));
Assert.That(version, Is.EqualTo("2018-11-09"));
Assert.That(response.TryGetHeader("x-ms-request-id", out _));
var bytes = new byte[response.ContentStream.Length];
await response.ContentStream.ReadAsync(bytes, 0, bytes.Length);
var content = GetString(bytes, bytes.Length);
Assert.That(content.Contains("<Error><Code>BlobNotFound</Code><Message>The specified blob does not exist."));
}
public async Task <Response <List <Response> > > SendBatchRequestAsync(HttpMessage message, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 202:
{
var responses = await Multipart.ParseAsync(
message.Response.ContentStream,
message.Response.Headers.ContentType,
true,
cancellationToken).ConfigureAwait(false);
return(Response.FromValue(responses.ToList(), message.Response));
}
default:
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false);
}
}
public async Task ParseBatchChangesetResponse()
{
var stream = MakeStream(TablesOdataBatchResponse);
var responses = await Multipart.ParseAsync(stream, ContentType, true, default);
Assert.That(responses, Is.Not.Null);
Assert.That(responses.Length, Is.EqualTo(3));
Assert.That(responses.All(r => r.Status == (int)HttpStatusCode.Created));
foreach (var response in responses)
{
Assert.That(response.TryGetHeader("DataServiceVersion", out var version));
Assert.That(version, Is.EqualTo("3.0;"));
Assert.That(response.TryGetHeader("Content-Type", out var contentType));
Assert.That(contentType, Is.EqualTo("application/json;odata=fullmetadata;streaming=true;charset=utf-8"));
var bytes = new byte[response.ContentStream.Length];
await response.ContentStream.ReadAsync(bytes, 0, bytes.Length);
var content = GetString(bytes, bytes.Length);
Assert.That(content, Is.EqualTo(Body));
}
}
public Response <List <Response> > SendBatchRequest(HttpMessage message, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
_pipeline.Send(message, cancellationToken);
switch (message.Response.Status)
{
case 202:
{
var responses = Multipart.ParseAsync(
message.Response.ContentStream,
message.Response.Headers.ContentType,
false,
cancellationToken).EnsureCompleted();
return(Response.FromValue(responses.ToList(), message.Response));
}
default:
throw _clientDiagnostics.CreateRequestFailedException(message.Response);
}
}
public async Task ParseBatchChangesetResponse(string batchResponse)
{
var stream = MakeStream(batchResponse);
var responses = await Multipart.ParseAsync(stream, ContentType, false, true, default);
Assert.That(responses, Is.Not.Null);
Assert.That(responses.Length, Is.EqualTo(1));
Assert.That(responses.All(r => r.Status == (int)HttpStatusCode.NoContent));
foreach (var response in responses)
{
Assert.That(response.TryGetHeader("Location", out var location));
Assert.That(location.Contains("RowKey='01'"));
Assert.That(response.TryGetHeader("Content-Type", out var contentType));
Assert.That(contentType, Is.EqualTo("application/json;odata=fullmetadata;streaming=true;charset=utf-8"));
var bytes = new byte[response.ContentStream.Length];
await response.ContentStream.ReadAsync(bytes, 0, bytes.Length);
var content = GetString(bytes, bytes.Length);
Assert.That(content, Is.EqualTo(string.Empty));
}
}
public Response <IReadOnlyList <Response> > SendBatchRequest(HttpMessage message, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
_pipeline.Send(message, cancellationToken);
switch (message.Response.Status)
{
case 202:
{
var responses = Multipart.ParseAsync(
message.Response.ContentStream,
message.Response.Headers.ContentType,
false,
false,
cancellationToken)
.EnsureCompleted();
var failedSubResponse = responses.FirstOrDefault(r => r.Status >= 400);
if (failedSubResponse == null)
{
return(Response.FromValue(responses.ToList() as IReadOnlyList <Response>, message.Response));
}
RequestFailedException rfex = ClientDiagnostics.CreateRequestFailedException(responses[0]);
var ex = new TableTransactionFailedException(rfex);
throw ex;
}
default:
throw ClientDiagnostics.CreateRequestFailedException(message.Response);
}
}
public Response <List <Response> > SendBatchRequest(HttpMessage message, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
_pipeline.Send(message, cancellationToken);
switch (message.Response.Status)
{
case 202:
{
var responses = Multipart.ParseAsync(
message.Response.ContentStream,
message.Response.Headers.ContentType,
expectBoundariesWithCRLF: false,
async: false,
cancellationToken).EnsureCompleted();
if (responses.Length == 1 && responses.Any(r => r.Status >= 400))
{
var ex = _clientDiagnostics.CreateRequestFailedException(responses[0]);
throw ex;
}
return(Response.FromValue(responses.ToList(), message.Response));
}
default:
throw _clientDiagnostics.CreateRequestFailedException(message.Response);
}
}
public async Task <Response <List <Response> > > SendBatchRequestAsync(HttpMessage message, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 202:
{
var responses = await Multipart.ParseAsync(
message.Response.ContentStream,
message.Response.Headers.ContentType,
expectBoundariesWithCRLF : false,
async : true,
cancellationToken).ConfigureAwait(false);
if (responses.Length == 1 && responses.Any(r => r.Status >= 400))
{
// Batch error messages should be formatted as follows:
// "0:<some error message>"
// where the number prefix is the index of the sub request that failed.
var ex = await _clientDiagnostics.CreateRequestFailedExceptionAsync(responses[0]).ConfigureAwait(false);
//Get the failed index
var match = s_entityIndexRegex.Match(ex.Message);
if (match.Success && int.TryParse(match.Groups["index"].Value, out int failedEntityIndex))
{
// create a new exception with the additional info populated.
var appendedMessage = AppendEntityInfoToMessage(ex.Message);
var rfe = new RequestFailedException(ex.Status, appendedMessage, ex.ErrorCode, ex.InnerException);
// Serialization of the entity is necessary because .NET framework enforces types added to Data as being serializable.
rfe.Data[TableConstants.ExceptionData.FailedEntityIndex] = failedEntityIndex;
throw rfe;
}
else
{
throw ex;
}
}
return(Response.FromValue(responses.ToList(), message.Response));
}
default:
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false);
}
}
