public async Task SendAsync_CallsControllerExecuteAsyncWithPopulatedControllerContext()
{
HttpControllerContext calledContext = null;
var mockSelector = new Mock <IHttpControllerSelector>();
var mockDescriptor = new Mock <HttpControllerDescriptor>();
var mockController = new Mock <IHttpController>();
var config = new HttpConfiguration();
config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
var request = CreateRequest(config, "http://localhost/api/foo");
mockSelector.Setup(s => s.SelectController(request))
.Returns(mockDescriptor.Object);
mockDescriptor.Setup(d => d.CreateController(request))
.Returns(mockController.Object);
mockDescriptor.Object.Initialize(config);
mockController.Setup(c => c.ExecuteAsync(It.IsAny <HttpControllerContext>(), CancellationToken.None))
.Callback((HttpControllerContext ctxt, CancellationToken token) => { calledContext = ctxt; });
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
await invoker.SendAsync(request, CancellationToken.None);
Assert.NotNull(calledContext);
Assert.Same(mockController.Object, calledContext.Controller);
Assert.Same(mockDescriptor.Object, calledContext.ControllerDescriptor);
Assert.Same(config, calledContext.Configuration);
Assert.Same(request, calledContext.Request);
Assert.Same(request.GetRouteData(), calledContext.RouteData);
}
public void SendAsync_CallsControllerExecuteAsyncWithPopulatedControllerContext()
{
HttpControllerContext calledContext = null;
var mockSelector = new Mock<IHttpControllerSelector>();
var mockDescriptor = new Mock<HttpControllerDescriptor>();
var mockController = new Mock<IHttpController>();
var config = new HttpConfiguration();
config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
var request = CreateRequest(config, "http://localhost/api/foo");
mockSelector.Setup(s => s.SelectController(request))
.Returns(mockDescriptor.Object);
mockDescriptor.Setup(d => d.CreateController(request))
.Returns(mockController.Object);
mockDescriptor.Object.Initialize(config);
mockController.Setup(c => c.ExecuteAsync(It.IsAny<HttpControllerContext>(), CancellationToken.None))
.Callback((HttpControllerContext ctxt, CancellationToken token) => { calledContext = ctxt; });
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
invoker.SendAsync(request, CancellationToken.None).WaitUntilCompleted();
Assert.NotNull(calledContext);
Assert.Same(mockController.Object, calledContext.Controller);
Assert.Same(mockDescriptor.Object, calledContext.ControllerDescriptor);
Assert.Same(config, calledContext.Configuration);
Assert.Same(request, calledContext.Request);
Assert.Same(request.GetRouteData(), calledContext.RouteData);
}
public async Task SendAsync_SetsRequestBackedRequestContextOnRequest_WhenRequestRequestContextIsNull()
{
// Arrange
using (HttpConfiguration configuration = new HttpConfiguration())
using (HttpControllerDispatcher dispatcher = new HttpControllerDispatcher(configuration))
using (HttpMessageInvoker invoker = new HttpMessageInvoker(dispatcher))
using (HttpRequestMessage request = new HttpRequestMessage())
{
Mock <IHttpController> controllerMock = new Mock <IHttpController>();
HttpRequestContext requestContext = null;
controllerMock
.Setup(c => c.ExecuteAsync(It.IsAny <HttpControllerContext>(), CancellationToken.None))
.Callback <HttpControllerContext, CancellationToken>((c, t) =>
{
requestContext = request.GetRequestContext();
});
Mock <HttpControllerDescriptor> controllerDescriptorMock = new Mock <HttpControllerDescriptor>();
controllerDescriptorMock.Setup(d => d.CreateController(request)).Returns(controllerMock.Object);
HttpControllerDescriptor controllerDescriptor = controllerDescriptorMock.Object;
controllerDescriptor.Configuration = configuration;
Mock <IHttpControllerSelector> controllerSelectorMock = new Mock <IHttpControllerSelector>();
controllerSelectorMock.Setup(s => s.SelectController(request)).Returns(controllerDescriptor);
configuration.Services.Replace(typeof(IHttpControllerSelector), controllerSelectorMock.Object);
request.SetRouteData(new Mock <IHttpRouteData>(MockBehavior.Strict).Object);
// Act
HttpResponseMessage ignore = await invoker.SendAsync(request, CancellationToken.None);
// Assert
RequestBackedHttpRequestContext typedRequestContext = Assert.IsType <RequestBackedHttpRequestContext>(requestContext);
Assert.Same(request, typedRequestContext.Request);
Assert.Same(configuration, typedRequestContext.Configuration);
}
}
public AuthenticationHandler(AuthenticationConfiguration configuration, HttpConfiguration httpConfiguration = null)
{
_authN = new HttpAuthentication(configuration);
if (httpConfiguration != null)
{
InnerHandler = new HttpControllerDispatcher(httpConfiguration);
}
}
public OAuth2Handler(HttpAuthentication authentication, HttpConfiguration httpConfiguration = null)
{
_authN = authentication;
if (httpConfiguration != null)
{
InnerHandler = new HttpControllerDispatcher(httpConfiguration);
}
}
public async Task SendAsync_Returns404WhenControllerSelectorReturnsNullControllerDescriptor()
{
var config = new HttpConfiguration();
var request = CreateRequest(config, "http://localhost/api/foo");
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public void SendAsync_Returns404WhenControllerSelectorReturnsNullControllerDescriptor()
{
var config = new HttpConfiguration();
var request = CreateRequest(config, "http://localhost/api/foo");
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
Task <HttpResponseMessage> resultTask = invoker.SendAsync(request, CancellationToken.None);
resultTask.WaitUntilCompleted();
Assert.Equal(HttpStatusCode.NotFound, resultTask.Result.StatusCode);
}
public void SendAsync_CallsControllerSelectorToGetControllerDescriptor()
{
var mockSelector = new Mock<IHttpControllerSelector>();
var config = new HttpConfiguration();
config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
var request = CreateRequest(config, "http://localhost/api/foo");
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
invoker.SendAsync(request, CancellationToken.None).WaitUntilCompleted();
mockSelector.Verify(s => s.SelectController(request), Times.Once());
}
public async Task SendAsync_CallsControllerSelectorToGetControllerDescriptor()
{
var mockSelector = new Mock <IHttpControllerSelector>();
var config = new HttpConfiguration();
config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
var request = CreateRequest(config, "http://localhost/api/foo");
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
await invoker.SendAsync(request, CancellationToken.None);
mockSelector.Verify(s => s.SelectController(request), Times.Once());
}
public void ExceptionHandlerGet_ReturnsSpecifiedInstance()
{
// Arrange
IExceptionLogger exceptionLogger = CreateDummyExceptionLogger();
IExceptionHandler expectedExceptionHandler = CreateDummyExceptionHandler();
using (HttpConfiguration configuration = CreateConfiguration())
using (HttpControllerDispatcher product = CreateProductUnderTest(configuration, exceptionLogger,
expectedExceptionHandler))
{
// Act
IExceptionHandler exceptionHandler = product.ExceptionHandler;
// Assert
Assert.Same(expectedExceptionHandler, exceptionHandler);
}
}
public async Task SendAsync_IfExceptionHandlerIsDefault_Returns500WithHttpErrorWhenControllerThrows()
{
var config = new HttpConfiguration()
{
IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always
};
var request = CreateRequest(config, "http://localhost/api/HttpControllerDispatcherThrowing");
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
var objectContent = Assert.IsType <ObjectContent <HttpError> >(response.Content);
var error = Assert.IsType <HttpError>(objectContent.Value);
Assert.Equal("Hello from the throwing controller", error["ExceptionMessage"]);
}
public void ExceptionHandlerGet_IfUnset_UsesExceptionHandlerFromConfiguration()
{
// Arrange
using (HttpConfiguration configuration = CreateConfiguration())
{
IExceptionHandler expectedExceptionHandler = CreateDummyExceptionHandler();
configuration.Services.Replace(typeof(IExceptionHandler), expectedExceptionHandler);
using (HttpControllerDispatcher product = CreateProductUnderTest(configuration))
{
// Act
IExceptionHandler exceptionHandler = product.ExceptionHandler;
// Assert
LastChanceExceptionHandler lastChanceHandler = Assert.IsType <LastChanceExceptionHandler>(exceptionHandler);
Assert.Same(expectedExceptionHandler, lastChanceHandler.InnerHandler);
}
}
}
public void SendAsync_CallsControllerDescriptorToCreateController()
{
var mockSelector = new Mock <IHttpControllerSelector>();
var mockDescriptor = new Mock <HttpControllerDescriptor>();
var config = new HttpConfiguration();
config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
var request = CreateRequest(config, "http://localhost/api/foo");
mockSelector.Setup(s => s.SelectController(request))
.Returns(mockDescriptor.Object);
mockDescriptor.Setup(d => d.CreateController(request))
.Returns(new PrivateController())
.Verifiable();
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
invoker.SendAsync(request, CancellationToken.None).WaitUntilCompleted();
mockDescriptor.Verify();
}
public void ExceptionLoggerGet_IfUnset_ReturnsExceptionLoggerFromConfiguration()
{
// Arrange
using (HttpConfiguration configuration = CreateConfiguration())
{
IExceptionLogger expectedExceptionLogger = CreateDummyExceptionLogger();
configuration.Services.Add(typeof(IExceptionLogger), expectedExceptionLogger);
using (HttpControllerDispatcher product = CreateProductUnderTest(configuration))
{
// Act
IExceptionLogger exceptionLogger = product.ExceptionLogger;
// Assert
CompositeExceptionLogger compositeLogger = Assert.IsType <CompositeExceptionLogger>(exceptionLogger);
IEnumerable <IExceptionLogger> loggers = compositeLogger.Loggers;
Assert.NotNull(loggers);
IExceptionLogger logger = Assert.Single(loggers);
Assert.Same(expectedExceptionLogger, logger);
}
}
}
public void SendAsync_CreatesControllerContext_WithRequestContextFromRequest()
{
// Arrange
using (HttpConfiguration configuration = new HttpConfiguration())
using (HttpControllerDispatcher dispatcher = new HttpControllerDispatcher(configuration))
using (HttpMessageInvoker invoker = new HttpMessageInvoker(dispatcher))
using (HttpRequestMessage request = new HttpRequestMessage())
{
Mock <IHttpController> controllerMock = new Mock <IHttpController>();
HttpRequestContext requestContext = null;
controllerMock
.Setup(c => c.ExecuteAsync(It.IsAny <HttpControllerContext>(), CancellationToken.None))
.Callback <HttpControllerContext, CancellationToken>((c, t) =>
{
requestContext = c.RequestContext;
});
Mock <HttpControllerDescriptor> controllerDescriptorMock = new Mock <HttpControllerDescriptor>();
controllerDescriptorMock.Setup(d => d.CreateController(request)).Returns(controllerMock.Object);
HttpControllerDescriptor controllerDescriptor = controllerDescriptorMock.Object;
controllerDescriptor.Configuration = configuration;
Mock <IHttpControllerSelector> controllerSelectorMock = new Mock <IHttpControllerSelector>();
controllerSelectorMock.Setup(s => s.SelectController(request)).Returns(controllerDescriptor);
configuration.Services.Replace(typeof(IHttpControllerSelector), controllerSelectorMock.Object);
HttpRequestContext expectedRequestContext = new HttpRequestContext
{
Configuration = configuration
};
request.SetRequestContext(expectedRequestContext);
request.SetRouteData(new Mock <IHttpRouteData>(MockBehavior.Strict).Object);
// Act
HttpResponseMessage ignore = invoker.SendAsync(request, CancellationToken.None).Result;
// Assert
Assert.Same(expectedRequestContext, requestContext);
}
}
private HttpServer GetTestCitiesServer(HttpConfiguration config)
{
HttpControllerDispatcher dispatcher = new HttpControllerDispatcher(config);
HttpRoute route = new HttpRoute("{controller}/{action}", new HttpRouteValueDictionary("Cities"));
config.Routes.Add("cities", route);
HttpServer server = new HttpServer(config, dispatcher);
return server;
}
public HttpServer(HttpControllerDispatcher dispatcher)
: this(new HttpConfiguration(), dispatcher)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="AccessTokenHandler"/> class.
/// </summary>
/// <param name="httpConfiguration">The HTTP configuration.</param>
public AccessTokenHandler(HttpConfiguration httpConfiguration)
{
InnerHandler = new HttpControllerDispatcher(httpConfiguration);
}
public void MapODataServiceRoute_MapsHandlerWhenAHandlerIsProvided()
{
// Arrange
HttpRouteCollection routes = new HttpRouteCollection();
HttpConfiguration config = new HttpConfiguration(routes);
IEdmModel model = new EdmModel();
HttpMessageHandler handler = new HttpControllerDispatcher(new HttpConfiguration());
// Act
ODataRoute route = config.MapODataServiceRoute("odata", "odata", model, handler);
// Assert
Assert.NotNull(route);
Assert.Same(handler, route.Handler);
}
private HttpResponseMessage ExecuteSelfHostRequest(string url, string controller, object data, string mediaType)
{
HttpConfiguration config = new HttpConfiguration();
IHttpRoute routeData;
if (!config.Routes.TryGetValue(controller, out routeData))
{
HttpRoute route = new HttpRoute("{controller}/{action}", new HttpRouteValueDictionary(controller));
config.Routes.Add(controller, route);
}
HttpControllerDispatcher dispatcher = new HttpControllerDispatcher(config);
HttpServer server = new HttpServer(config, dispatcher);
HttpMessageInvoker invoker = new HttpMessageInvoker(server);
string serializedChangeSet = String.Empty;
if (mediaType == "application/json")
{
JsonSerializer serializer = new JsonSerializer() { PreserveReferencesHandling = PreserveReferencesHandling.Objects, TypeNameHandling = TypeNameHandling.All };
MemoryStream ms = new MemoryStream();
JsonWriter writer = new JsonTextWriter(new StreamWriter(ms));
serializer.Serialize(writer, data);
writer.Flush();
ms.Seek(0, 0);
serializedChangeSet = Encoding.UTF8.GetString(ms.GetBuffer()).TrimEnd('\0');
}
else
{
DataContractSerializer ser = new DataContractSerializer(data.GetType(), GetTestKnownTypes());
MemoryStream ms = new MemoryStream();
ser.WriteObject(ms, data);
ms.Flush();
ms.Seek(0, 0);
serializedChangeSet = Encoding.UTF8.GetString(ms.GetBuffer()).TrimEnd('\0');
}
HttpRequestMessage request = TestHelpers.CreateTestMessage(url, HttpMethod.Post, config);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(mediaType));
request.Content = new StringContent(serializedChangeSet, Encoding.UTF8, mediaType);
return invoker.SendAsync(request, CancellationToken.None).Result;
}
public void SendAsync_Returns404WhenControllerSelectorReturnsNullControllerDescriptor()
{
var config = new HttpConfiguration();
var request = CreateRequest(config, "http://localhost/api/foo");
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
Task<HttpResponseMessage> resultTask = invoker.SendAsync(request, CancellationToken.None);
resultTask.WaitUntilCompleted();
Assert.Equal(HttpStatusCode.NotFound, resultTask.Result.StatusCode);
}
public void SendAsync_SetsRequestBackedRequestContextOnRequest_WhenRequestRequestContextIsNull()
{
// Arrange
using (HttpConfiguration configuration = new HttpConfiguration())
using (HttpControllerDispatcher dispatcher = new HttpControllerDispatcher(configuration))
using (HttpMessageInvoker invoker = new HttpMessageInvoker(dispatcher))
using (HttpRequestMessage request = new HttpRequestMessage())
{
Mock<IHttpController> controllerMock = new Mock<IHttpController>();
HttpRequestContext requestContext = null;
controllerMock
.Setup(c => c.ExecuteAsync(It.IsAny<HttpControllerContext>(), CancellationToken.None))
.Callback<HttpControllerContext, CancellationToken>((c, t) =>
{
requestContext = request.GetRequestContext();
});
Mock<HttpControllerDescriptor> controllerDescriptorMock = new Mock<HttpControllerDescriptor>();
controllerDescriptorMock.Setup(d => d.CreateController(request)).Returns(controllerMock.Object);
HttpControllerDescriptor controllerDescriptor = controllerDescriptorMock.Object;
controllerDescriptor.Configuration = configuration;
Mock<IHttpControllerSelector> controllerSelectorMock = new Mock<IHttpControllerSelector>();
controllerSelectorMock.Setup(s => s.SelectController(request)).Returns(controllerDescriptor);
configuration.Services.Replace(typeof(IHttpControllerSelector), controllerSelectorMock.Object);
request.SetRouteData(new Mock<IHttpRouteData>(MockBehavior.Strict).Object);
// Act
HttpResponseMessage ignore = invoker.SendAsync(request, CancellationToken.None).Result;
// Assert
Assert.IsType<RequestBackedHttpRequestContext>(requestContext);
RequestBackedHttpRequestContext typedRequestContext = (RequestBackedHttpRequestContext)requestContext;
Assert.Same(request, typedRequestContext.Request);
Assert.Same(configuration, typedRequestContext.Configuration);
}
}
public ClaimsTransformationHandler(ClaimsAuthenticationManager transformer, HttpConfiguration configuration)
{
_transfomer = transformer;
InnerHandler = new HttpControllerDispatcher(configuration);
}
public ApiKeyHandler(HttpConfiguration httpConfiguration)
{
InnerHandler = new HttpControllerDispatcher(httpConfiguration);
}
public void SendAsync_Returns500WithHttpErrorWhenControllerThrows()
{
var config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };
var request = CreateRequest(config, "http://localhost/api/HttpControllerDispatcherThrowing");
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
Task<HttpResponseMessage> resultTask = invoker.SendAsync(request, CancellationToken.None);
resultTask.WaitUntilCompleted();
Assert.Equal(HttpStatusCode.InternalServerError, resultTask.Result.StatusCode);
var objectContent = Assert.IsType<ObjectContent<HttpError>>(resultTask.Result.Content);
var error = Assert.IsType<HttpError>(objectContent.Value);
Assert.Equal("Hello from the throwing controller", error["ExceptionMessage"]);
}
public HttpProxy(HttpConfiguration httpConfiguration, string key)
{
InnerHandler = new HttpControllerDispatcher(httpConfiguration);
this.Key = key;
}
