public void CreateActionModel_AttributeRouteOnAction()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(NoRouteAttributeOnControllerController).GetTypeInfo();
var actionName = nameof(NoRouteAttributeOnControllerController.Edit);
// Act
var action = builder.CreateActionModel(typeInfo, typeInfo.AsType().GetMethod(actionName));
// Assert
Assert.NotNull(action);
Assert.Single(action.Selectors);
var methodConstraint = Assert.Single(
action.Selectors[0].ActionConstraints.OfType <HttpMethodActionConstraint>());
Assert.Equal(actionName, action.ActionName);
var httpMethod = Assert.Single(methodConstraint.HttpMethods);
Assert.Equal("HEAD", httpMethod);
var attributeRoute = Assert.Single(GetAttributeRoutes(action.Selectors));
Assert.Equal("Change", attributeRoute.Template);
Assert.IsType <HttpHeadAttribute>(Assert.Single(action.Attributes));
}
public void CreateActionModel_RouteOnController_CreatesOneActionInforPerRouteTemplateOnAction(Type controller)
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = controller.GetTypeInfo();
// Act
var action = builder.CreateActionModel(typeInfo, typeInfo.AsType().GetMethod("Index"));
// Assert
Assert.NotNull(action.Attributes);
Assert.Equal(2, action.Attributes.Count);
Assert.Equal(2, action.Selectors.Count);
Assert.Equal("Index", action.ActionName);
foreach (var selectorModel in action.Selectors)
{
var methodConstraint = Assert.Single(selectorModel.ActionConstraints.OfType <HttpMethodActionConstraint>());
var httpMethod = Assert.Single(methodConstraint.HttpMethods);
Assert.Equal("GET", httpMethod);
Assert.NotNull(selectorModel.AttributeRouteModel.Template);
}
Assert.Single(action.Selectors, ai => ai.AttributeRouteModel.Template.Equals("List"));
Assert.Single(action.Selectors, ai => ai.AttributeRouteModel.Template.Equals("All"));
}
public void CreateActionModel_AttributeRouteOnAction_AcceptVerbsAttributeWithTemplate()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(NoRouteAttributeOnControllerController).GetTypeInfo();
var actionName = nameof(NoRouteAttributeOnControllerController.List);
// Act
var action = builder.CreateActionModel(typeInfo, typeInfo.AsType().GetMethod(actionName));
// Assert
Assert.NotNull(action);
Assert.Single(action.Selectors);
var methodConstraint = Assert.Single(
action.Selectors[0].ActionConstraints.OfType <HttpMethodActionConstraint>());
Assert.Equal(actionName, action.ActionName);
Assert.Equal(
new[] { "GET", "HEAD" },
methodConstraint.HttpMethods.OrderBy(m => m, StringComparer.Ordinal));
var attributeRoute = Assert.Single(GetAttributeRoutes(action.Selectors));
Assert.Equal("ListAll", attributeRoute.Template);
Assert.IsType <AcceptVerbsAttribute>(Assert.Single(action.Attributes));
}
public void BuildActionModels_RouteOnController_CreatesOneActionInforPerRouteTemplateOnAction(Type controller)
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = controller.GetTypeInfo();
// Act
var actions = builder.BuildActionModels(typeInfo, typeInfo.GetMethod("Index"));
// Assert
Assert.Equal(2, actions.Count());
foreach (var action in actions)
{
Assert.Equal("Index", action.ActionName);
var httpMethod = Assert.Single(action.HttpMethods);
Assert.Equal("GET", httpMethod);
Assert.NotNull(action.AttributeRouteModel.Template);
Assert.IsType <HttpGetAttribute>(Assert.Single(action.Attributes));
}
Assert.Single(actions, ai => ai.AttributeRouteModel.Template.Equals("List"));
Assert.Single(actions, ai => ai.AttributeRouteModel.Template.Equals("All"));
}
public void BuildActionModels_AttributeRouteOnAction_CreatesOneActionInforPerRouteTemplate()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(NoRouteAttributeOnControllerController).GetTypeInfo();
var actionName = nameof(NoRouteAttributeOnControllerController.Index);
// Act
var actions = builder.BuildActionModels(typeInfo, typeInfo.GetMethod(actionName));
// Assert
Assert.Equal(2, actions.Count());
foreach (var action in actions)
{
Assert.Equal("Index", action.ActionName);
Assert.NotNull(action.AttributeRouteModel);
}
var list = Assert.Single(actions, ai => ai.AttributeRouteModel.Template.Equals("List"));
var listMethod = Assert.Single(list.HttpMethods);
Assert.Equal("POST", listMethod);
Assert.IsType <HttpPostAttribute>(Assert.Single(list.Attributes));
var all = Assert.Single(actions, ai => ai.AttributeRouteModel.Template.Equals("All"));
var allMethod = Assert.Single(all.HttpMethods);
Assert.Equal("GET", allMethod);
Assert.IsType <HttpGetAttribute>(Assert.Single(all.Attributes));
}
public void CreateActionModel_MixedHttpVerbsAndRoutes_MultipleEmptyAndNonEmptyVerbsWithMultipleRoutes()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(MixedHttpVerbsAndRouteAttributeController).GetTypeInfo();
var actionName = nameof(MixedHttpVerbsAndRouteAttributeController.MultipleVerbsWithAnyWithoutTemplateAndRoutes);
// Act
var action = builder.CreateActionModel(typeInfo, typeInfo.AsType().GetMethod(actionName));
// Assert
Assert.Equal(3, action.Selectors.Count);
var selectorModel = Assert.Single(action.Selectors, s => s.AttributeRouteModel.Template == "Products");
var methodConstraint = Assert.Single(selectorModel.ActionConstraints.OfType <HttpMethodActionConstraint>());
Assert.Equal <string>(new string[] { "GET" }, methodConstraint.HttpMethods);
selectorModel = Assert.Single(action.Selectors, s => s.AttributeRouteModel.Template == "v2/Products");
methodConstraint = Assert.Single(selectorModel.ActionConstraints.OfType <HttpMethodActionConstraint>());
Assert.Equal <string>(new string[] { "GET" }, methodConstraint.HttpMethods);
selectorModel = Assert.Single(action.Selectors, s => s.AttributeRouteModel.Template == "Products/Buy");
methodConstraint = Assert.Single(selectorModel.ActionConstraints.OfType <HttpMethodActionConstraint>());
Assert.Equal <string>(new string[] { "POST" }, methodConstraint.HttpMethods);
}
public void CreateControllerModel_ClassWithFilterInterfaces_UnsupportedType()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(UnsupportedFiltersController).GetTypeInfo();
// Act
var model = builder.CreateControllerModel(typeInfo);
// Assert
Assert.Empty(model.Filters);
}
public void CreateControllerModel_ClassWithFilterInterfaces_HasFilter()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(SomeFiltersController).GetTypeInfo();
// Act
var model = builder.CreateControllerModel(typeInfo);
// Assert
Assert.Single(model.Filters, f => f is ControllerActionFilter);
Assert.Single(model.Filters, f => f is ControllerResultFilter);
}
public void CreateControllerModel_DerivedFromControllerClass_HasFilter()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(StoreController).GetTypeInfo();
// Act
var model = builder.CreateControllerModel(typeInfo);
// Assert
var filter = Assert.Single(model.Filters);
Assert.IsType <ControllerActionFilter>(filter);
}
public void IsAction_OverridenMethodControllerClass()
{
// Arrange
var builder = new TestApplicationModelProvider();
var method = typeof(BaseController).GetMethod(nameof(BaseController.Redirect));
Assert.NotNull(method);
// Act
var isValid = builder.IsAction(typeof(BaseController).GetTypeInfo(), method);
// Assert
Assert.False(isValid);
}
public void IsAction_WithInheritedMethods(string methodName, bool expected)
{
// Arrange
var builder = new TestApplicationModelProvider();
var method = typeof(DerivedController).GetMethod(methodName);
Assert.NotNull(method);
// Act
var isValid = builder.IsAction(typeof(DerivedController).GetTypeInfo(), method);
// Assert
Assert.Equal(expected, isValid);
}
public void CreateControllerModel_ClassWithoutFilterInterfaces_HasNoControllerFilter()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(NoFiltersController).GetTypeInfo();
// Act
var model = builder.CreateControllerModel(typeInfo);
// Assert
var filter = Assert.Single(model.Filters);
Assert.IsType <MyFilterAttribute>(filter);
}
public void IsAction_OverridenNonActionMethod()
{
// Arrange
var builder = new TestApplicationModelProvider();
var method = typeof(DerivedController).GetMethod("OverridenNonActionMethod");
Assert.NotNull(method);
// Act
var isValid = builder.IsAction(typeof(DerivedController).GetTypeInfo(), method);
// Assert
Assert.False(isValid);
}
public void IsAction_OperatorOverloadingMethod_FromOperatorOverloadingController()
{
// Arrange
var builder = new TestApplicationModelProvider();
var method = typeof(OperatorOverloadingController).GetMethod("op_Addition");
Assert.NotNull(method);
Assert.True(method.IsSpecialName);
// Act
var isValid = builder.IsAction(typeof(OperatorOverloadingController).GetTypeInfo(), method);
// Assert
Assert.False(isValid);
}
public void IsAction_NewDisposeMethod()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(DerivedNewDisposeController).GetTypeInfo();
var method = typeInfo.GetDeclaredMethods("Dispose").SingleOrDefault();
Assert.NotNull(method);
// Act
var isValid = builder.IsAction(typeInfo, method);
// Assert
Assert.True(isValid);
}
public void ControllerDispose_ExplicitlyImplemented_IDisposableMethods_AreTreatedAs_NonActions()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(DerivedFromControllerAndExplicitIDisposableImplementationController).GetTypeInfo();
var context = new ApplicationModelProviderContext(new[] { typeInfo });
// Act
builder.OnProvidersExecuting(context);
// Assert
var model = Assert.Single(context.Result.Controllers);
Assert.Empty(model.Actions);
}
public void IsAction_StaticMethods(string methodName)
{
// Arrange
var builder = new TestApplicationModelProvider();
var method = typeof(DerivedController).GetMethod(
methodName,
BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
Assert.NotNull(method);
// Act
var isValid = builder.IsAction(typeof(DerivedController).GetTypeInfo(), method);
// Assert
Assert.False(isValid);
}
public void BuildActionModels_MixedHttpVerbsAndRoutes_EmptyVerbWithRoute()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(MixedHttpVerbsAndRouteAttributeController).GetTypeInfo();
var actionName = nameof(MixedHttpVerbsAndRouteAttributeController.VerbAndRoute);
// Act
var actions = builder.BuildActionModels(typeInfo, typeInfo.GetMethod(actionName));
// Assert
var action = Assert.Single(actions);
Assert.Equal <string>(new string[] { "GET" }, action.HttpMethods);
Assert.Equal("Products", action.AttributeRouteModel.Template);
}
public void IsAction_PrivateMethod_FromUserDefinedController()
{
// Arrange
var builder = new TestApplicationModelProvider();
var method = typeof(DerivedController).GetMethod(
"PrivateMethod",
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
Assert.NotNull(method);
// Act
var isValid = builder.IsAction(typeof(DerivedController).GetTypeInfo(), method);
// Assert
Assert.False(isValid);
}
public void IsAction_PocoControllerIDisposableDisposeMethod()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(IDisposablePocoController).GetTypeInfo();
var methodInfo =
typeInfo.GetRuntimeInterfaceMap(typeof(IDisposable)).TargetMethods[0];
var method = typeInfo.AsType().GetMethods().SingleOrDefault(m => (m == methodInfo));
Assert.NotNull(method);
// Act
var isValid = builder.IsAction(typeInfo, method);
// Assert
Assert.False(isValid);
}
public void ControllerDispose_MethodsNamedDispose_AreTreatedAsActions()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(DerivedFromControllerAndHidesBaseDisposeMethodController).GetTypeInfo();
var context = new ApplicationModelProviderContext(new[] { typeInfo });
// Act
builder.OnProvidersExecuting(context);
// Assert
var model = Assert.Single(context.Result.Controllers);
var action = Assert.Single(model.Actions);
// Make sure that the Dispose method is from the derived controller and not the base 'Controller' type
Assert.Equal(typeInfo, action.ActionMethod.DeclaringType.GetTypeInfo());
}
public void BuildActionModels_ConventionallyRoutedAction_WithoutHttpConstraints()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(ConventionallyRoutedController).GetTypeInfo();
var actionName = nameof(ConventionallyRoutedController.Edit);
// Act
var actions = builder.BuildActionModels(typeInfo, typeInfo.GetMethod(actionName));
// Assert
var action = Assert.Single(actions);
Assert.Equal("Edit", action.ActionName);
Assert.Empty(action.HttpMethods);
Assert.Null(action.AttributeRouteModel);
Assert.Empty(action.Attributes);
}
public void CreateActionModel_ConventionallyRoutedAction_WithoutHttpConstraints()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(ConventionallyRoutedController).GetTypeInfo();
var actionName = nameof(ConventionallyRoutedController.Edit);
// Act
var action = builder.CreateActionModel(typeInfo, typeInfo.AsType().GetMethod(actionName));
// Assert
Assert.NotNull(action);
Assert.Equal(actionName, action.ActionName);
Assert.Empty(action.Attributes);
Assert.Single(action.Selectors);
Assert.Empty(action.Selectors[0].ActionConstraints.OfType <HttpMethodActionConstraint>());
Assert.Empty(GetAttributeRoutes(action.Selectors));
}
public void IsAction_SimplePocoControllerDisposeMethod()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(SimplePocoController).GetTypeInfo();
var methods = typeInfo.AsType().GetMethods().Where(m => m.Name.Equals("Dispose"));
Assert.NotEmpty(methods);
foreach (var method in methods)
{
// Act
var isValid = builder.IsAction(typeInfo, method);
// Assert
Assert.True(isValid);
}
}
public void BuildActionModels_ConventionallyRoutedAction_WithMultipleOverlappingHttpConstraints()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(ConventionallyRoutedController).GetTypeInfo();
var actionName = nameof(ConventionallyRoutedController.List);
// Act
var actions = builder.BuildActionModels(typeInfo, typeInfo.GetMethod(actionName));
// Assert
var action = Assert.Single(actions);
Assert.Contains("GET", action.HttpMethods);
Assert.Contains("PUT", action.HttpMethods);
Assert.Contains("POST", action.HttpMethods);
Assert.Equal("List", action.ActionName);
Assert.Null(action.AttributeRouteModel);
}
public void CreateActionModel_RouteAttributeOnController_CreatesAttributeRoute_ForNonAttributedActions(Type controller)
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = controller.GetTypeInfo();
// Act
var action = builder.CreateActionModel(typeInfo, typeInfo.AsType().GetMethod("Delete"));
// Assert
Assert.NotNull(action);
Assert.Equal("Delete", action.ActionName);
Assert.Single(action.Selectors);
Assert.Empty(action.Selectors[0].ActionConstraints);
Assert.Empty(GetAttributeRoutes(action.Selectors));
Assert.Empty(action.Attributes);
}
public void CreateActionModel_NoRouteOnController_AllowsConventionallyRoutedActions_OnTheSameController()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(NoRouteAttributeOnControllerController).GetTypeInfo();
var actionName = nameof(NoRouteAttributeOnControllerController.Remove);
// Act
var action = builder.CreateActionModel(typeInfo, typeInfo.AsType().GetMethod(actionName));
// Assert
Assert.NotNull(action);
Assert.Equal(actionName, action.ActionName);
Assert.Empty(action.Attributes);
Assert.Single(action.Selectors);
Assert.Empty(action.Selectors[0].ActionConstraints);
Assert.Null(action.Selectors[0].AttributeRouteModel);
}
public void BuildActionModels_RouteAttributeOnController_CreatesAttributeRoute_ForNonAttributedActions(Type controller)
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = controller.GetTypeInfo();
// Act
var actions = builder.BuildActionModels(typeInfo, typeInfo.GetMethod("Delete"));
// Assert
var action = Assert.Single(actions);
Assert.Equal("Delete", action.ActionName);
Assert.Empty(action.HttpMethods);
Assert.Null(action.AttributeRouteModel);
Assert.Empty(action.Attributes);
}
public void BuildActionModels_MixedHttpVerbsAndRoutes_MultipleEmptyAndNonEmptyVerbs()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(MixedHttpVerbsAndRouteAttributeController).GetTypeInfo();
var actionName = nameof(MixedHttpVerbsAndRouteAttributeController.Invalid);
// Act
var actions = builder.BuildActionModels(typeInfo, typeInfo.GetMethod(actionName));
// Assert
Assert.Equal(2, actions.Count());
var action = Assert.Single(actions, a => a.AttributeRouteModel?.Template == "Products");
Assert.Equal <string>(new string[] { "POST" }, action.HttpMethods);
action = Assert.Single(actions, a => a.AttributeRouteModel?.Template == null);
Assert.Equal <string>(new string[] { "GET" }, action.HttpMethods);
}
public void IsAction_PocoControllerDisposeMethod()
{
// Arrange
var builder = new TestApplicationModelProvider();
var typeInfo = typeof(IDisposablePocoController).GetTypeInfo();
var methodInfo =
typeInfo.GetRuntimeInterfaceMap(typeof(IDisposable)).TargetMethods[0];
var methods = typeInfo.AsType().GetMethods().Where(m => m.Name.Equals("Dispose") && m != methodInfo);
Assert.NotEmpty(methods);
foreach (var method in methods)
{
// Act
var isValid = builder.IsAction(typeInfo, method);
// Assert
Assert.True(isValid);
}
}
