public void SelectAction_RespectsDirectRoutes()
{
var actionSelector = new ApiControllerActionSelector();
HttpControllerContext context = ContextUtil.CreateControllerContext();
context.Request = new HttpRequestMessage {
Method = HttpMethod.Get
};
var controllerDescriptor = new HttpControllerDescriptor(
context.Configuration,
"Users",
typeof(UsersController)
);
context.ControllerDescriptor = controllerDescriptor;
ReflectedHttpActionDescriptor directRouteAction =
(ReflectedHttpActionDescriptor)actionSelector.GetActionMapping(
controllerDescriptor
)["Get"].First();
context.RouteData.Route.DataTokens.Add(
"actions",
new ReflectedHttpActionDescriptor[] { directRouteAction }
);
HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(context);
Assert.Same(directRouteAction, actionDescriptor);
}
public static RouteInfo RouteRequest(HttpConfiguration config, HttpRequestMessage request)
{
// create context
var controllerContext = new HttpControllerContext(config, Substitute.For <IHttpRouteData>(), request);
// get route data
var routeData = config.Routes.GetRouteData(request);
RemoveOptionalRoutingParameters(routeData.Values);
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
controllerContext.RouteData = routeData;
// get controller type
var controllerDescriptor = new DefaultHttpControllerSelector(config).SelectController(request);
controllerContext.ControllerDescriptor = controllerDescriptor;
// get action name
var actionMapping = new ApiControllerActionSelector().SelectAction(controllerContext);
return(new RouteInfo
{
Controller = controllerDescriptor.ControllerType,
Action = actionMapping.ActionName
});
}
public void SelectAction_With_DifferentExecutionContexts()
{
ApiControllerActionSelector actionSelector = new ApiControllerActionSelector();
HttpControllerContext GetContext = ContextUtil.CreateControllerContext();
HttpControllerDescriptor usersControllerDescriptor = new HttpControllerDescriptor(GetContext.Configuration, "Users", typeof(UsersController));
usersControllerDescriptor.Configuration.Services.Replace(typeof(IHttpActionSelector), actionSelector);
GetContext.ControllerDescriptor = usersControllerDescriptor;
GetContext.Request = new HttpRequestMessage
{
Method = HttpMethod.Get
};
HttpControllerContext PostContext = ContextUtil.CreateControllerContext();
usersControllerDescriptor.Configuration.Services.Replace(typeof(IHttpActionSelector), actionSelector);
PostContext.ControllerDescriptor = usersControllerDescriptor;
PostContext.Request = new HttpRequestMessage
{
Method = HttpMethod.Post
};
HttpActionDescriptor getActionDescriptor = actionSelector.SelectAction(GetContext);
HttpActionDescriptor postActionDescriptor = actionSelector.SelectAction(PostContext);
Assert.Equal("Get", getActionDescriptor.ActionName);
Assert.Equal("Post", postActionDescriptor.ActionName);
}
private static HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
var actionSelector = new ApiControllerActionSelector();
var actionDescriptor = actionSelector.SelectAction(controllerContext);
return(actionDescriptor);
}
public void SelectAction_WithDirectRoutes_RespectsPrecedence()
{
// Arrange
var actionSelector = new ApiControllerActionSelector();
HttpControllerContext context = ContextUtil.CreateControllerContext();
context.Request = new HttpRequestMessage {
Method = HttpMethod.Get
};
var controllerDescriptor = new HttpControllerDescriptor(context.Configuration, "MultipleGet", typeof(MultipleGetController));
context.ControllerDescriptor = controllerDescriptor;
ReflectedHttpActionDescriptor firstDirectRouteAction = (ReflectedHttpActionDescriptor)actionSelector.GetActionMapping(controllerDescriptor)["GetA"].Single();
HttpRouteData[] subRouteData = new HttpRouteData[2];
subRouteData[0] = new HttpRouteData(new HttpRoute());
subRouteData[1] = new HttpRouteData(new HttpRoute());
context.RouteData.Values.Add(RouteCollectionRoute.SubRouteDataKey, subRouteData);
subRouteData[0].Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { firstDirectRouteAction });
subRouteData[0].Route.DataTokens.Add("precedence", 2M);
ReflectedHttpActionDescriptor secondDirectRouteAction = (ReflectedHttpActionDescriptor)actionSelector.GetActionMapping(controllerDescriptor)["GetB"].Single();
subRouteData[1].Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { secondDirectRouteAction });
subRouteData[1].Route.DataTokens.Add("precedence", 1M);
// Act
HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(context);
// Assert
Assert.Same(secondDirectRouteAction, actionDescriptor);
}
public static HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
ApiControllerActionSelector selector = new ApiControllerActionSelector();
HttpActionDescriptor descriptor = selector.SelectAction(controllerContext);
return(descriptor);
}
public void SelectAction_Throws_IfContextIsNull()
{
ApiControllerActionSelector actionSelector = new ApiControllerActionSelector();
Assert.ThrowsArgumentNull(
() => actionSelector.SelectAction(null),
"controllerContext");
}
public RouteTests()
{
this.routes = new HttpRouteCollection();
this.configuration = new HttpConfiguration(this.routes);
RouteConfig.RegisterRoutes(this.configuration);
this.configuration.EnsureInitialized();
this.controllerSelector = new DefaultHttpControllerSelector(this.configuration);
this.actionSelector = new ApiControllerActionSelector();
}
private HttpActionDescriptor GetActionDescriptor()
{
if (descriptor == null)
{
var actionSelector = new ApiControllerActionSelector();
descriptor = actionSelector.SelectAction(controllerContext);
}
return(descriptor);
}
public string GetActionName()
{
if (controllerContext.ControllerDescriptor == null)
{
GetControllerType();
}
var actionSelector = new ApiControllerActionSelector();
var descriptor = actionSelector.SelectAction(controllerContext);
return(descriptor.ActionName);
}
public static List <HttpActionDescriptor> GetControllerActions(Type ControllerType)
{
if (!typeof(ApiController).IsAssignableFrom(ControllerType))
{
throw new NotSupportedException($"Getting actions from controller:{ControllerType.Name} not supported because it doesn't inherit from type {typeof(ApiController).Name}");
}
ApiControllerActionSelector ApiControllerSelection = new ApiControllerActionSelector();
HttpControllerDescriptor ApiDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), ControllerType.Name, ControllerType);
ILookup <string, HttpActionDescriptor> ApiMappings = ApiControllerSelection.GetActionMapping(ApiDescriptor);
return(ApiMappings.SelectMany(a => a).ToList());
}
private static string GetHandlerText(HttpRequestMessage request, HttpConfiguration config, IHttpRouteData routeData, HttpControllerDescriptor httpControllerDescriptor)
{
var controllerContext = new HttpControllerContext(config, routeData, request)
{
RouteData = routeData, ControllerDescriptor = httpControllerDescriptor
};
var actionMapping = new ApiControllerActionSelector().SelectAction(controllerContext);
var text = string.Format("Handled By: {0}.{1}({2})", actionMapping.ControllerDescriptor.ControllerType.FullName, actionMapping.ActionName, GetParameterString(actionMapping.ActionBinding.ParameterBindings, controllerContext.RouteData));
return(text);
}
public void HttpActionSelector_Property()
{
IHttpActionSelector selector = new ApiControllerActionSelector();
HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor();
Assert.Reflection.Property <HttpControllerDescriptor, IHttpActionSelector>(
instance: controllerDescriptor,
propertyGetter: cd => cd.HttpActionSelector,
expectedDefaultValue: null,
allowNull: false,
roundTripTestValue: selector);
}
public TestControllerBuilder(HttpRequestMessage request, HttpConfiguration httpConfiguration)
{
var routeData = request.Properties[HttpPropertyKeys.HttpRouteDataKey] as IHttpRouteData;
controllerContext = new HttpControllerContext(httpConfiguration, routeData, request);
IHttpControllerSelector controllerSelector = httpConfiguration.Services.GetHttpControllerSelector();
controlleDescriptor = controllerSelector.SelectController(request);
controllerContext.ControllerDescriptor = controlleDescriptor;
actionSelector = new ApiControllerActionSelector();
this.httpConfiguration = httpConfiguration;
requestMessage = request;
}
public void ConventionOnlyOnPost()
{
// Arrange
ControllerContext controllerContext = GetControllerContext("GET", routeValues: new { action = "post" });
ApiControllerActionSelector selector = new ApiControllerActionSelector();
// Act
ExceptionHelper.ExpectHttpException(
delegate() { selector.SelectAction(controllerContext); },
"The requested resource does not support http method 'GET'.",
405 // HttpStatusCode: MethodNotAllowed
);
}
public void ConventionGetQueryable()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
// Act
ApiControllerActionSelector selector = new ApiControllerActionSelector();
ApiActionDescriptor actionDescriptor = (ApiActionDescriptor)selector.SelectAction(controllerContext);
// Assert
Assert.AreEqual("get", actionDescriptor.ActionName, true);
Assert.AreEqual(0, actionDescriptor.GetParameters().Length);
Assert.AreEqual(typeof(IQueryable<UserModel>), actionDescriptor.ReturnType);
}
public RouteContext(HttpConfiguration config, HttpRequestMessage request)
{
var routeData = config.Routes.GetRouteData(request);
request.SetRouteData(routeData);
var controllerSelector = new DefaultHttpControllerSelector(config);
var descriptor = controllerSelector.SelectController(request);
ControllerType = descriptor.ControllerType;
var actionSelector = new ApiControllerActionSelector();
_actionMappings = actionSelector.GetActionMapping(descriptor).SelectMany(x => x).Where(x => x.SupportedHttpMethods.Contains(request.Method));
}
public RouteContext(HttpConfiguration config, HttpRequestMessage request)
{
var routeData = config.Routes.GetRouteData(request);
request.SetRouteData(routeData);
var controllerSelector = new DefaultHttpControllerSelector(config);
var descriptor = controllerSelector.SelectController(request);
ControllerType = descriptor.ControllerType;
var actionSelector = new ApiControllerActionSelector();
_actionMappings = actionSelector.GetActionMapping(descriptor)[request.Method.ToString()];
}
public void ConventionPost()
{
// Arrange
ControllerContext controllerContext = GetControllerContext("POST");
// Act
ApiControllerActionSelector selector = new ApiControllerActionSelector();
ApiActionDescriptor actionDescriptor = (ApiActionDescriptor)selector.SelectAction(controllerContext);
// Assert
Assert.AreEqual("post", actionDescriptor.ActionName, true);
Assert.AreEqual(1, actionDescriptor.GetParameters().Length);
Assert.AreEqual(typeof(UserModel), actionDescriptor.GetParameters()[0].ParameterType);
}
public void ConventionGetWithId()
{
// Arrange
ControllerContext controllerContext = GetControllerContext(routeValues: new { id = 3 });
// Act
ApiControllerActionSelector selector = new ApiControllerActionSelector();
ApiActionDescriptor actionDescriptor = (ApiActionDescriptor)selector.SelectAction(controllerContext);
// Assert
Assert.AreEqual("get", actionDescriptor.ActionName, true);
Assert.AreEqual(1, actionDescriptor.GetParameters().Length);
Assert.AreEqual(typeof(UserModel), actionDescriptor.ReturnType);
}
public void GetActionMapping_IgnoresNonAction()
{
var actionSelector = new ApiControllerActionSelector();
HttpControllerContext context = ContextUtil.CreateControllerContext();
context.Request = new HttpRequestMessage {
Method = HttpMethod.Get
};
var controllerDescriptor = new HttpControllerDescriptor(context.Configuration, "NonAction", typeof(NonActionController));
context.ControllerDescriptor = controllerDescriptor;
var mapping = actionSelector.GetActionMapping(controllerDescriptor);
Assert.False(mapping.Contains("GetA"));
Assert.True(mapping.Contains("GetB"));
}
private string GetActionName()
{
try
{
if (_controllerContext.ControllerDescriptor == null)
{
GetControllerType();
}
var actionSelector = new ApiControllerActionSelector();
var descriptor = actionSelector.SelectAction(_controllerContext);
return(descriptor.ActionName);
}
catch (Exception exception)
{
Console.WriteLine(exception.ToString());
return("<Null>");
}
}
/// <summary>
/// Routes the request.
/// </summary>
/// <param name="config">The config.</param>
/// <param name="request">The request.</param>
/// <returns>Inbformation about the route.</returns>
public static RouteInfo RouteRequest(HttpConfiguration config, HttpRequestMessage request)
{
// create context
var controllerContext = new HttpControllerContext(config, new Mock <IHttpRouteData>().Object, request);
// get route data
var routeData = config.Routes.GetRouteData(request);
RemoveOptionalRoutingParameters(routeData.Values);
HttpActionDescriptor actionDescriptor = null;
HttpControllerDescriptor controllerDescriptor = null;
// Handle web api 2 attribute routes
if (routeData.Values.ContainsKey("MS_SubRoutes"))
{
var subroutes = (IEnumerable <IHttpRouteData>)routeData.Values["MS_SubRoutes"];
routeData = subroutes.First();
actionDescriptor = ((HttpActionDescriptor[])routeData.Route.DataTokens.First(token => token.Key == "actions").Value).First();
controllerDescriptor = actionDescriptor.ControllerDescriptor;
}
else
{
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
controllerContext.RouteData = routeData;
// get controller type
controllerDescriptor = new DefaultHttpControllerSelector(config).SelectController(request);
controllerContext.ControllerDescriptor = controllerDescriptor;
// get action name
actionDescriptor = new ApiControllerActionSelector().SelectAction(controllerContext);
}
return(new RouteInfo
{
Controller = controllerDescriptor.ControllerType,
Action = actionDescriptor.ActionName,
RouteData = routeData
});
}
public static void AssertAction <T>(this HttpConfiguration config, string expectedAction, HttpMethod method, string requestUri)
where T : ApiController
{
// Check controller
var request = new HttpRequestMessage(method, new Uri(BaseUri, requestUri));
IHttpRouteData routeData = config.Routes.GetRouteData(request);
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
HttpControllerDescriptor controller;
Type controllerType = null;
try
{
controller = new DefaultHttpControllerSelector(config).SelectController(request);
controllerType = controller.ControllerType;
}
catch (HttpResponseException)
{
controller = null;
}
Assert.AreEqual(typeof(T), controllerType);
// Check action
var context = new HttpControllerContext(config, routeData, request)
{
ControllerDescriptor = controller
};
string actionName;
try
{
actionName = new ApiControllerActionSelector().SelectAction(context).ActionName;
}
catch (HttpResponseException)
{
actionName = null;
}
Assert.AreEqual(expectedAction, actionName);
}
private HttpActionDescriptor MakeActionDescriptor()
{
var actionSelector = new ApiControllerActionSelector();
return(actionSelector.SelectAction(controllerContext));
}
private HttpActionDescriptor GetActionDescriptor(HttpControllerContext controllerContext)
{
ApiControllerActionSelector actionSelector = new ApiControllerActionSelector();
return(actionSelector.SelectAction(controllerContext));
}
public ElevationActionSelector(HttpConfiguration config)
{
this.config = config;
_defaultSelector = new ApiControllerActionSelector();
}
//<summary>Recibe la peticion del servidor antes de que llegue al controlador para realzar el log de la peticion.</summary>
/// <param name="cancellationToken"></param>
/// <param name="request">Objeto que contiene informacion de las peticiones.</param>
/// <returns>Respuesta del servidor</returns>
protected override async System.Threading.Tasks.Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
{
using (IUnitOfWork unitOfWork = new UnitOfWork())
{
IRepository <ApiLog> repository = new Repository <ApiLog>(unitOfWork);
IRepository <User> repositoryUser = new Repository <User>(unitOfWork);
apiLogService = new ApiLogService(repository);
userService = new UserService(repositoryUser);
StringBuilder content = new StringBuilder();
string requestUuid = request.GetCorrelationId().ToString();
HttpConfiguration config = GlobalConfiguration.Configuration;
IHttpRouteData routeData = config.Routes.GetRouteData(request);
HttpControllerContext controllerContext = new HttpControllerContext(config, routeData, request);
DefaultHttpControllerSelector controllerSelector = new DefaultHttpControllerSelector(config);
HttpControllerDescriptor controllerDescriptor = controllerSelector.SelectController(request);
ApiControllerActionSelector apiControllerSelection = new ApiControllerActionSelector();
controllerContext.ControllerDescriptor = controllerDescriptor;
HttpActionDescriptor actionDescriptor = apiControllerSelection.SelectAction(controllerContext);
ApiLog requestLog = new ApiLog();
requestLog.Uuid = requestUuid;
requestLog.Controller = controllerDescriptor.ControllerName;
requestLog.Action = actionDescriptor.ActionName;
//Obtiene y decodifica el post para que se muestre la informacion de la manera adecuada
string data = HttpUtility.UrlDecode(request.Content.ReadAsStringAsync().Result);
requestLog.Data = data;
requestLog.CreatedAt = DateTime.Now;
requestLog.Url = request.RequestUri.AbsoluteUri;//request.RequestUri.Host + HttpUtility.UrlDecode(request.RequestUri.PathAndQuery);
requestLog.Method = request.Method.Method;
requestLog.Status = "Started";
object headers = request.Headers.ToDictionary(x => x.Key, y => y.Value);
requestLog.Headers = JsonConvert.SerializeObject(headers);
//unitOfWork.BeginTransaction();
try
{
apiLogService.Create(requestLog);
//unitOfWork.Commit();
}
catch (Exception e)
{
//unitOfWork.Rollback();
}
//Se espera la respuesta del controlador
var response = await base.SendAsync(request, cancellationToken);
requestUuid = request.GetCorrelationId().ToString();
//unitOfWork.BeginTransaction();
try
{
requestLog = apiLogService.FindBy(x => x.Uuid == requestUuid).FirstOrDefault();
User user = null;
int? userId = UserApiAuthenticated.GetUserAuthenticatedId(request.GetRequestContext());
if (userId.HasValue)
{
user = userService.GetById(userId.Value);
}
if (user != null)
{
requestLog.CreatedBy = user;
}
if (requestLog != null)
{
if (response.RequestMessage != null && response.Content != null)
{
var responseContent = await response.Content.ReadAsStringAsync();
if (requestLog.Exception != null)
{
requestLog.Status = "HasException";
}
else
{
requestLog.Status = "Completed";
}
requestLog.Result = responseContent.ToString();
apiLogService.Update(requestLog);
}
}
//unitOfWork.Commit();
}catch (Exception e)
{
//unitOfWork.Rollback();
}
return(response);
}
}
public void ConventionPut()
{
// Arrange
ControllerContext controllerContext = GetControllerContext("PUT", routeValues: new { id = 3 });
// Act
ApiControllerActionSelector selector = new ApiControllerActionSelector();
ApiActionDescriptor actionDescriptor = (ApiActionDescriptor)selector.SelectAction(controllerContext);
// Assert
Assert.AreEqual("put", actionDescriptor.ActionName, true);
Assert.AreEqual(2, actionDescriptor.GetParameters().Length);
Assert.AreEqual(typeof(int), actionDescriptor.GetParameters()[0].ParameterType);
Assert.AreEqual(typeof(UserModel), actionDescriptor.GetParameters()[1].ParameterType);
}