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 async Task 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/")
};
await Assert.ThrowsAsync <InvalidOperationException>(
() => batchHandler.ExecuteRequestMessagesAsync(requests, CancellationToken.None)
);
Assert.Equal(2, responses.Count);
foreach (var response in responses)
{
Assert.True(response.IsDisposed);
}
}
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);
}
/// <summary>
/// Sets all the values needed to run Test.API.
/// </summary>
/// <param name="config">
/// Http configuration values.
/// </param>
public static void Configure(HttpConfiguration config)
{
HttpBatchHandler batchHandler = new DefaultHttpBatchHandler(GlobalConfiguration.DefaultServer)
{
ExecutionOrder
=
BatchExecutionOrder
.NonSequential
};
config.Routes.MapHttpBatchRoute("Bulk", "bulk", batchHandler);
config.Routes.MapHttpRoute("ApiWithFormat", "{controller}/{id}.{ext}", new { ext = "json" });
config.Routes.MapHttpRoute("ApiBasicWithFormat", "{controller}.{ext}", new { ext = "json" });
config.Routes.MapHttpRoute("ApiBasic", "{controller}/{id}", new { id = RouteParameter.Optional });
config.Routes.MapHttpRoute("RootInformation", string.Empty, new { Controller = "Home", Action = "Get" });
config.Routes.MapHttpRoute("ApiPublic", "public/{controller}/{id}", new { id = RouteParameter.Optional });
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter());
config.MessageHandlers.Add(new BearerTokenAuthenticationHandler());
// config.MessageHandlers.Add(new CacheControlHandler());
// config.MessageHandlers.Add(new ETagHandler());
// config.MessageHandlers.Insert(0, new CompressionHandler());
ConfigureFormatters(config);
ConfigureCastlerWindsor(config);
}
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 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
}
protected void Application_Start()
{
LoggingConfig.SetupLogging();
var logger = LogManager.GetCurrentClassLogger();
logger.Info("Current process ID: {ProcessID}, ELASTIC_APM_SERVER_URLS: {ELASTIC_APM_SERVER_URLS}",
Process.GetCurrentProcess().Id, Environment.GetEnvironmentVariable("ELASTIC_APM_SERVER_URLS"));
// Web API setup
HttpBatchHandler batchHandler = new DefaultHttpBatchHandler(GlobalConfiguration.DefaultServer)
{
ExecutionOrder = BatchExecutionOrder.NonSequential
};
var configuration = GlobalConfiguration.Configuration;
RouteConfig.RegisterWebApiRoutes(configuration, batchHandler);
GlobalConfiguration.Configure(WebApiConfig.Register);
// MVC setup
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
ValueProviderFactories.Factories.Remove(ValueProviderFactories.Factories.OfType <JsonValueProviderFactory>().FirstOrDefault());
ValueProviderFactories.Factories.Add(new JsonNetValueProviderFactory());
}
public async Task ParseBatchRequestsAsync_Returns_RequestsFromMultipartContent_WithUriSchemeSet_FromRequest()
{
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, "https://example.com/values")
)
},
RequestUri = new Uri("https://example.com/")
};
IList <HttpRequestMessage> requests = await batchHandler.ParseBatchRequestsAsync(
request,
CancellationToken.None
);
Assert.Equal(2, requests.Count);
Assert.Equal(HttpMethod.Get, requests[0].Method);
Assert.Equal("https://example.com/", requests[0].RequestUri.AbsoluteUri);
Assert.Equal(HttpMethod.Post, requests[1].Method);
Assert.Equal("https://example.com/values", requests[1].RequestUri.AbsoluteUri);
}
public async Task 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 = await batchHandler.ExecuteRequestMessagesAsync(
requests,
CancellationToken.None
);
Assert.Equal(2, responses.Count);
Assert.Equal("http://example.com/", await responses[0].Content.ReadAsStringAsync());
Assert.Equal("http://example.org/", await responses[1].Content.ReadAsStringAsync());
}
public static void Register(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
HttpBatchHandler batchHandler = new DefaultHttpBatchHandler(GlobalConfiguration.DefaultServer)
{
ExecutionOrder = BatchExecutionOrder.NonSequential
};
var server = new HttpServer(config);
config.Routes.MapHttpBatchRoute(
routeName: "batch",
routeTemplate: "data/batch",
batchHandler: new DefaultHttpBatchHandler(server));
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "data/{controller}/{action}"
);
var routePublisher = EngineContext.Current.Resolve <IHttpRoutePublisher>();
routePublisher.RegisterHttpRoutes(config.Routes);
}
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.SetUrlHelper(new UrlHelper());
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 async Task CreateResponseMessageAsync_ReturnsMultipartContent()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
HttpResponseMessage[] responses = new HttpResponseMessage[]
{
new HttpResponseMessage(HttpStatusCode.OK),
new HttpResponseMessage(HttpStatusCode.BadRequest)
};
HttpResponseMessage response = await batchHandler.CreateResponseMessageAsync(
responses,
new HttpRequestMessage(),
CancellationToken.None
);
MultipartContent content = Assert.IsType <MultipartContent>(response.Content);
List <HttpResponseMessage> nestedResponses = new List <HttpResponseMessage>();
foreach (var part in content)
{
nestedResponses.Add(await part.ReadAsHttpResponseMessageAsync());
}
Assert.Equal(2, nestedResponses.Count);
Assert.Equal(HttpStatusCode.OK, nestedResponses[0].StatusCode);
Assert.Equal(HttpStatusCode.BadRequest, nestedResponses[1].StatusCode);
}
public void ParseBatchRequestsAsync_Throws_IfRequestIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.ParseBatchRequestsAsync(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);
}
public void ExecuteRequestMessagesAsync_Throws_IfRequestsAreNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.ExecuteRequestMessagesAsync(null, CancellationToken.None).Wait(),
"requests");
}
public Task ProcessBatchAsync_Throws_IfRequestIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
return(Assert.ThrowsArgumentNullAsync(
() => batchHandler.ProcessBatchAsync(null, CancellationToken.None),
"request"));
}
public void CreateResponseMessageAsync_Throws_IfRequestIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.CreateResponseMessageAsync(new HttpResponseMessage[0], null).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 ProcessBatchAsync_Throws_IfRequestIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.ProcessBatchAsync(null, CancellationToken.None).Wait(),
"request");
}
public void ValidateRequest_Throws_IfRequestIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.ValidateRequest(null),
"request");
}
public Task CreateResponseMessageAsync_Throws_IfRequestIsNull()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
return(Assert.ThrowsArgumentNullAsync(
() => batchHandler.CreateResponseMessageAsync(new HttpResponseMessage[0], null, CancellationToken.None),
"request"));
}
public void ExecutionOrder_ThrowsWhenTheValueIsInvalid()
{
DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
Assert.ThrowsInvalidEnumArgument(
() => batchHandler.ExecutionOrder = (BatchExecutionOrder)20,
"value",
20,
typeof(BatchExecutionOrder));
}
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);
}
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 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 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 static void Register(HttpConfiguration config)
{
#region Web API Batching
// Configuration et services API Web
var batchHandler = new DefaultHttpBatchHandler(GlobalConfiguration.DefaultServer)
{
ExecutionOrder = BatchExecutionOrder.NonSequential
};
config.Routes.MapHttpBatchRoute(
routeName: "WebApiBatch",
routeTemplate: "api/batch",
batchHandler: batchHandler);
#endregion
// Itinéraires de l'API Web
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
