public void ConvertResponse_Returns_Error_Response_When_Formatter_Write_Throws_Immediately()
{
// Arrange
Mock <JsonMediaTypeFormatter> formatterMock = new Mock <JsonMediaTypeFormatter>()
{
CallBase = true
};
formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny <Type>(),
It.IsAny <object>(),
It.IsAny <Stream>(),
It.IsAny <HttpContent>(),
It.IsAny <TransportContext>())).Throws(new NotSupportedException("Expected error"));
MemoryStream memoryStream = new MemoryStream();
Mock <HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
HttpResponseBase responseBase = contextMock.Object.Response;
HttpRequestMessage request = new HttpRequestMessage();
request.Properties.Add(HttpPropertyKeys.IsLocalKey, new Lazy <bool>(() => true));
HttpResponseMessage response = new HttpResponseMessage()
{
RequestMessage = request
};
response.Content = new ObjectContent <string>("hello", formatterMock.Object);
// Act
Task task = HttpControllerHandler.ConvertResponse(contextMock.Object, response, request);
task.Wait();
// Assert preparation -- deserialize the HttpError response
HttpError httpError = null;
memoryStream.Seek(0L, SeekOrigin.Begin);
using (StreamContent content = new StreamContent(memoryStream))
{
content.Headers.ContentType = JsonMediaTypeFormatter.DefaultMediaType;
httpError = content.ReadAsAsync <HttpError>().Result;
}
// Assert
Assert.Equal <int>((int)HttpStatusCode.InternalServerError, responseBase.StatusCode);
Assert.True(responseBase.Headers["Content-Type"].StartsWith(JsonMediaTypeFormatter.DefaultMediaType.MediaType));
Assert.Equal("An error has occurred.", httpError["Message"]);
Assert.Equal("The 'ObjectContent`1' type failed to serialize the response body for content type 'application/json; charset=utf-8'.", httpError["ExceptionMessage"]);
Assert.Equal(typeof(InvalidOperationException).FullName, httpError["ExceptionType"]);
Assert.True(httpError.ContainsKey("StackTrace"));
HttpError innerError = (httpError["InnerException"] as JObject).ToObject <HttpError>();
Assert.NotNull(innerError);
Assert.Equal(typeof(NotSupportedException).FullName, innerError["ExceptionType"].ToString());
Assert.Equal("Expected error", innerError["ExceptionMessage"]);
Assert.Contains("System.Net.Http.HttpContent.CopyToAsync", innerError["StackTrace"].ToString());
}
private static void Main(string[] args)
{
const int TotalRun = 10 * 1000;
var customerController = new CustomerController();
var orderController = new OrderController();
var customer = customerController.Get(1);
var orders = new List <Order>();
foreach (var orderId in customer.OrderIds)
{
orders.Add(orderController.Get(1, orderId));
}
var fullCustomer = new FullCustomer(customer)
{
Orders = orders
};
var s = JsonConvert.SerializeObject(fullCustomer);
var bytes = Encoding.UTF8.GetBytes(s);
var stream = new MemoryStream(bytes);
var content = new StreamContent(stream);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var stopwatch = Stopwatch.StartNew();
for (int i = 1; i < TotalRun + 1; i++)
{
var a = content.ReadAsAsync <FullCustomer>().Result;
if (i % 100 == 0)
{
Console.Write("\r" + i);
}
}
Console.WriteLine();
Console.WriteLine(stopwatch.Elapsed);
stopwatch.Restart();
for (int i = 1; i < TotalRun + 1; i++)
{
var sa = content.ReadAsStringAsync().Result;
var a = JsonConvert.DeserializeObject <FullCustomer>(sa);
if (i % 100 == 0)
{
Console.Write("\r" + i);
}
}
Console.WriteLine();
Console.WriteLine(stopwatch.Elapsed);
Console.Read();
}
private async Task BindFromBody(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
{
var bodyBinding = _descriptor.BindWithAttribute(new FromBodyAttribute());
var memoryStream = new MemoryStream();
await actionContext.Request.Content.CopyToAsync(memoryStream);
memoryStream.Position = 0;
var content = new StreamContent(memoryStream);
actionContext.Request.Content.Headers.AsEnumerable().ToList().ForEach(x => content.Headers.TryAddWithoutValidation(x.Key, x.Value));
actionContext.Request.Content = new StreamContent(memoryStream);
await bodyBinding.ExecuteBindingAsync(metadataProvider, actionContext, cancellationToken);
var query = GetValue(actionContext) as IClientQuery;
if (query == null)
{
SetValue(actionContext, null);
return;
}
var clientFilterable = query as IClientFilterable;
var clientSortable = query as IClientSortable;
var clientPageable = query as IClientPageable;
memoryStream.Position = 0;
var apiQuery = await content.ReadAsAsync(typeof(ApiQuery), actionContext.ControllerContext.Configuration.Formatters, cancellationToken) as ApiQuery;
if (apiQuery == null)
{
return;
}
if (clientFilterable != null && apiQuery.Filter != null && !(apiQuery.Filter is AlwaysTrueFilter))
{
clientFilterable.ClientFilter = apiQuery.Filter;
}
if (clientSortable != null && apiQuery.Sort != null && !(apiQuery.Sort is RandomSort))
{
clientSortable.ClientSort = apiQuery.Sort;
}
if (clientPageable != null && (apiQuery.PageSize != null && apiQuery.PageNumber != null))
{
clientPageable.ClientPage = new ClientPage
{
PageNumber = apiQuery.PageNumber,
PageSize = apiQuery.PageSize
};
}
SetValue(actionContext, query);
}
