public static void Register(HttpConfiguration config)
{
#region Web API Batching
// Web API configuration and services
var batchHandler = new DefaultHttpBatchHandler(GlobalConfiguration.DefaultServer)
{
ExecutionOrder = BatchExecutionOrder.NonSequential
};
config.Routes.MapHttpBatchRoute(
routeName: "WebApiBatch",
routeTemplate: "api/batch",
batchHandler: batchHandler);
#endregion
#region Authentification
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(Startup.OAuthServerOptions.AuthenticationType));
#endregion
#region Attribute Routing
// Web API routes
config.MapHttpAttributeRoutes();
#endregion
}
public void ProcessBatchAsync_Throws_IfRequestIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.ProcessBatchAsync(null, CancellationToken.None).Wait(),
"request");
}
public void CreateResponseMessageAsync_Throws_IfResponsesAreNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.CreateResponseMessageAsync(null, new HttpRequestMessage(), CancellationToken.None).Wait(),
"responses");
}
public void CreateResponseMessageAsync_Throws_IfRequestIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.CreateResponseMessageAsync(new HttpResponseMessage[0], null).Wait(),
"request");
}
public void Parameter_Constructor()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.Equal(BatchExecutionOrder.Sequential, batchHandler.ExecutionOrder);
Assert.NotNull(batchHandler.Invoker);
Assert.Contains("multipart/mixed", batchHandler.SupportedContentTypes);
}
static void Main(string[] args)
{
var baseAddress = "http://localhost:8080";
HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress);
// config.MessageHandlers.Add(new ProgressMessageHandler() { });
// Web API 路由
config.MapHttpAttributeRoutes();
//全局允许CROS
// config.EnableCors();//启用跨域
config.Routes.MapHttpRoute
(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.MaxConcurrentRequests = 1000;
var handlers = new DelegatingHandler[] { new PassiveAuthenticationMessageHandler(), new HttpServer() };
var routeHandlers = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(config), handlers);
config.Routes.MapHttpRoute(
name: "CustomerRouter",
routeTemplate: "MyAPI/{Controller}/{Action}/Id",
defaults: new { Id = RouteParameter.Optional },
constraints: null,
handler: routeHandlers
);
HttpSelfHostServer server = new HttpSelfHostServer(config);
server.OpenAsync();
TaskManager.Instance.Initialize();
TaskManager.Instance.Start();
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server);
Console.WriteLine("Server http://localhost:8080 Open now ....at {0}..", server.Configuration.VirtualPathRoot);
config.EnsureInitialized();
foreach (var route in config.Routes)
{
System.Diagnostics.Debug.WriteLine(route);
}
Console.ReadLine();
}
public void CreateResponseMessageAsync_ReturnsMultipartContent()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
HttpResponseMessage[] responses = new HttpResponseMessage[]
{
new HttpResponseMessage(HttpStatusCode.OK),
new HttpResponseMessage(HttpStatusCode.BadRequest)
};
HttpResponseMessage response = batchHandler.CreateResponseMessageAsync(responses, new HttpRequestMessage()).Result;
MultipartContent content = Assert.IsType<MultipartContent>(response.Content);
List<HttpResponseMessage> nestedResponses = new List<HttpResponseMessage>();
foreach (var part in content)
{
nestedResponses.Add(part.ReadAsHttpResponseMessageAsync().Result);
}
Assert.Equal(2, nestedResponses.Count);
Assert.Equal(HttpStatusCode.OK, nestedResponses[0].StatusCode);
Assert.Equal(HttpStatusCode.BadRequest, nestedResponses[1].StatusCode);
}
public void ValidateRequest_Throws_IfRequestMediaTypeIsWrong()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent(String.Empty);
request.Content.Headers.ContentType = new MediaTypeHeaderValue("text/json");
HttpResponseException errorResponse = Assert.Throws<HttpResponseException>(
() => batchHandler.ValidateRequest(request));
Assert.Equal(HttpStatusCode.BadRequest, errorResponse.Response.StatusCode);
Assert.Equal("The batch request of media type 'text/json' is not supported.",
errorResponse.Response.Content.ReadAsAsync<HttpError>().Result.Message);
}
public void ValidateRequest_Throws_IfRequestContentTypeIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent(String.Empty);
request.Content.Headers.ContentType = null;
HttpResponseException errorResponse = Assert.Throws<HttpResponseException>(
() => batchHandler.ValidateRequest(request));
Assert.Equal(HttpStatusCode.BadRequest, errorResponse.Response.StatusCode);
Assert.Equal("The batch request must have a \"Content-Type\" header.",
errorResponse.Response.Content.ReadAsAsync<HttpError>().Result.Message);
}
public void ValidateRequest_Throws_IfRequestContentIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
HttpRequestMessage request = new HttpRequestMessage();
HttpResponseException errorResponse = Assert.Throws<HttpResponseException>(
() => batchHandler.ValidateRequest(request));
Assert.Equal(HttpStatusCode.BadRequest, errorResponse.Response.StatusCode);
Assert.Equal("The 'Content' property on the batch request cannot be null.",
errorResponse.Response.Content.ReadAsAsync<HttpError>().Result.Message);
}
public void ValidateRequest_Throws_IfRequestIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.ValidateRequest(null),
"request");
}
public void ParseBatchRequestsAsync_Returns_RequestsFromMultipartContent()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
HttpRequestMessage request = new HttpRequestMessage
{
Content = new MultipartContent("mixed")
{
new HttpMessageContent(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
new HttpMessageContent(new HttpRequestMessage(HttpMethod.Post, "http://example.com/values"))
}
};
IList<HttpRequestMessage> requests = batchHandler.ParseBatchRequestsAsync(request).Result;
Assert.Equal(2, requests.Count);
Assert.Equal(HttpMethod.Get, requests[0].Method);
Assert.Equal("http://example.com/", requests[0].RequestUri.AbsoluteUri);
Assert.Equal(HttpMethod.Post, requests[1].Method);
Assert.Equal("http://example.com/values", requests[1].RequestUri.AbsoluteUri);
}
public void ParseBatchRequestsAsync_Throws_IfRequestIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.ParseBatchRequestsAsync(null).Wait(),
"request");
}
public void ParseBatchRequestsAsync_CopiesPropertiesFromRequest_WithoutExcludedProperties()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
HttpRequestMessage request = new HttpRequestMessage
{
Content = new MultipartContent("mixed")
{
new HttpMessageContent(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
new HttpMessageContent(new HttpRequestMessage(HttpMethod.Post, "http://example.com/values"))
}
};
request.Properties.Add("foo", "bar");
request.SetRouteData(new HttpRouteData(new HttpRoute()));
request.RegisterForDispose(new StringContent(String.Empty));
IList<HttpRequestMessage> requests = batchHandler.ParseBatchRequestsAsync(request, CancellationToken.None).Result;
Assert.Equal(2, requests.Count);
Assert.Equal(HttpMethod.Get, requests[0].Method);
Assert.Equal("bar", requests[0].Properties["foo"]);
Assert.Null(requests[0].GetRouteData());
Assert.Same(requests[0], requests[0].GetUrlHelper().Request);
Assert.Empty(requests[0].GetResourcesForDisposal());
Assert.Equal("http://example.com/", requests[0].RequestUri.AbsoluteUri);
Assert.Equal(HttpMethod.Post, requests[1].Method);
Assert.Equal("http://example.com/values", requests[1].RequestUri.AbsoluteUri);
Assert.Equal("bar", requests[1].Properties["foo"]);
Assert.Null(requests[1].GetRouteData());
Assert.Same(requests[1], requests[1].GetUrlHelper().Request);
Assert.Empty(requests[1].GetResourcesForDisposal());
}
public void ExecuteRequestMessagesAsync_DisposesResponseInCaseOfException()
{
List<DisposableResponseMessage> responses = new List<DisposableResponseMessage>();
MockHttpServer server = new MockHttpServer(request =>
{
if (request.Method == HttpMethod.Put)
{
throw new InvalidOperationException();
}
var response = new DisposableResponseMessage();
responses.Add(response);
return response;
});
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server);
HttpRequestMessage[] requests = new HttpRequestMessage[]
{
new HttpRequestMessage(HttpMethod.Get, "http://example.com/"),
new HttpRequestMessage(HttpMethod.Post, "http://example.com/"),
new HttpRequestMessage(HttpMethod.Put, "http://example.com/")
};
Assert.Throws<InvalidOperationException>(
() => batchHandler.ExecuteRequestMessagesAsync(requests, CancellationToken.None).Result);
Assert.Equal(2, responses.Count);
foreach (var response in responses)
{
Assert.True(response.IsDisposed);
}
}
public void ExecuteRequestMessagesAsync_CallsInvokerForEachRequest()
{
MockHttpServer server = new MockHttpServer(request =>
{
return new HttpResponseMessage { Content = new StringContent(request.RequestUri.AbsoluteUri) };
});
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server);
HttpRequestMessage[] requests = new HttpRequestMessage[]
{
new HttpRequestMessage(HttpMethod.Get, "http://example.com/"),
new HttpRequestMessage(HttpMethod.Post, "http://example.org/")
};
var responses = batchHandler.ExecuteRequestMessagesAsync(requests, CancellationToken.None).Result;
Assert.Equal(2, responses.Count);
Assert.Equal("http://example.com/", responses[0].Content.ReadAsStringAsync().Result);
Assert.Equal("http://example.org/", responses[1].Content.ReadAsStringAsync().Result);
}
public void ExecuteRequestMessagesAsync_Throws_IfRequestsAreNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.ExecuteRequestMessagesAsync(null, CancellationToken.None).Wait(),
"requests");
}
public void ExecutionOrder_ThrowsWhenTheValueIsInvalid()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsInvalidEnumArgument(
() => batchHandler.ExecutionOrder = (BatchExecutionOrder)20,
"value",
20,
typeof(BatchExecutionOrder));
}
public void ProcessBatchAsync_CallsRegisterForDispose()
{
List<IDisposable> expectedResourcesForDisposal = new List<IDisposable>();
MockHttpServer server = new MockHttpServer(request =>
{
var tmpContent = new StringContent(String.Empty);
request.RegisterForDispose(tmpContent);
expectedResourcesForDisposal.Add(tmpContent);
return new HttpResponseMessage { Content = new StringContent(request.RequestUri.AbsoluteUri) };
});
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server);
HttpRequestMessage batchRequest = new HttpRequestMessage
{
Content = new MultipartContent("mixed")
{
new HttpMessageContent(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
new HttpMessageContent(new HttpRequestMessage(HttpMethod.Post, "http://example.org/"))
}
};
var response = batchHandler.ProcessBatchAsync(batchRequest, CancellationToken.None).Result;
var resourcesForDisposal = batchRequest.GetResourcesForDisposal();
foreach (var expectedResource in expectedResourcesForDisposal)
{
Assert.Contains(expectedResource, resourcesForDisposal);
}
}
public void ExecuteRequestMessagesAsync_SequentialExecutionCallInvokerForEachRequest()
{
List<HttpRequestMessage> completedRequests = new List<HttpRequestMessage>();
MockHttpServer server = new MockHttpServer(async request =>
{
if (request.Method == HttpMethod.Get)
{
await Task.Delay(2000);
}
completedRequests.Add(request);
return new HttpResponseMessage();
});
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server)
{
ExecutionOrder = BatchExecutionOrder.Sequential
};
HttpRequestMessage[] requests = new HttpRequestMessage[]
{
new HttpRequestMessage(HttpMethod.Get, "http://example.com/"),
new HttpRequestMessage(HttpMethod.Post, "http://example.com/")
};
batchHandler.ExecuteRequestMessagesAsync(requests, CancellationToken.None).Wait();
Assert.Equal(2, completedRequests.Count);
Assert.Equal(HttpMethod.Get, completedRequests[0].Method);
Assert.Equal(HttpMethod.Post, completedRequests[1].Method);
}
public async Task WebHost_Batching_WithSpecialCharactersInUrl()
{
// Arrange
var handler = new SuccessMessageHandler();
var routeCollection = new HostedHttpRouteCollection(new RouteCollection(), "/");
routeCollection.Add("default", routeCollection.CreateRoute(
"values/ space",
defaults: null,
constraints: null,
dataTokens: null,
handler: handler));
var configuration = new HttpConfiguration(routeCollection);
var server = new HttpServer(configuration);
var batchHandler = new DefaultHttpBatchHandler(server);
var request = new HttpRequestMessage
{
Content = new MultipartContent("mixed")
{
new HttpMessageContent(new HttpRequestMessage(HttpMethod.Post, "http://contoso.com/values/ space"))
}
};
// Arrange
var response = await batchHandler.ProcessBatchAsync(request, CancellationToken.None);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.True(handler.IsCalled);
}
