public void Apply(ControllerModel controller) { if (IsConventionApplicable(controller)) { var newActions = new List<ActionModel>(); foreach (var action in controller.Actions) { SetHttpMethodFromConvention(action); // Action Name doesn't really come into play with attribute routed actions. However for a // non-attribute-routed action we need to create a 'named' version and an 'unnamed' version. if (!IsActionAttributeRouted(action)) { var namedAction = action; var unnamedAction = new ActionModel(namedAction); unnamedAction.RouteConstraints.Add(new UnnamedActionRouteConstraint()); newActions.Add(unnamedAction); } } foreach (var action in newActions) { controller.Actions.Add(action); } } }
public void CopyConstructor_DoesDeepCopyOfOtherModels() { // Arrange var controller = new ControllerModel(typeof(TestController).GetTypeInfo(), new List<object>()); var action = new ActionModel(typeof(TestController).GetMethod("Edit"), new List<object>()); controller.Actions.Add(action); action.Controller = controller; var route = new AttributeRouteModel(new HttpGetAttribute("api/Products")); controller.AttributeRoutes.Add(route); var apiExplorer = controller.ApiExplorer; controller.ApiExplorer.GroupName = "group"; controller.ApiExplorer.IsVisible = true; // Act var controller2 = new ControllerModel(controller); // Assert Assert.NotSame(action, controller2.Actions[0]); Assert.NotSame(route, controller2.AttributeRoutes[0]); Assert.NotSame(apiExplorer, controller2.ApiExplorer); Assert.NotSame(controller.ActionConstraints, controller2.ActionConstraints); Assert.NotSame(controller.Actions, controller2.Actions); Assert.NotSame(controller.Attributes, controller2.Attributes); Assert.NotSame(controller.Filters, controller2.Filters); Assert.NotSame(controller.RouteConstraints, controller2.RouteConstraints); }
public ControllerModel(ControllerModel other) { if (other == null) { throw new ArgumentNullException(nameof(other)); } ControllerName = other.ControllerName; ControllerType = other.ControllerType; // Still part of the same application Application = other.Application; // These are just metadata, safe to create new collections ActionConstraints = new List<IActionConstraintMetadata>(other.ActionConstraints); Attributes = new List<object>(other.Attributes); Filters = new List<IFilterMetadata>(other.Filters); RouteConstraints = new List<IRouteConstraintProvider>(other.RouteConstraints); Properties = new Dictionary<object, object>(other.Properties); // Make a deep copy of other 'model' types. Actions = new List<ActionModel>(other.Actions.Select(a => new ActionModel(a))); ApiExplorer = new ApiExplorerModel(other.ApiExplorer); AttributeRoutes = new List<AttributeRouteModel>( other.AttributeRoutes.Select(a => new AttributeRouteModel(a))); ControllerProperties = new List<PropertyModel>(other.ControllerProperties.Select(p => new PropertyModel(p))); }
public void Apply(ControllerModel controller) { if (IsConventionApplicable(controller)) { controller.RouteConstraints.Add(new AreaAttribute(_area)); } }
public void Build_WithControllerPropertiesSet_AddsPropertiesWithBinderMetadataSet() { // Arrange var applicationModel = new ApplicationModel(); var controller = new ControllerModel(typeof(TestController).GetTypeInfo(), new List<object>() { }); controller.ControllerProperties.Add( new PropertyModel( controller.ControllerType.GetProperty("BoundProperty"), new List<object>() { }) { BindingInfo = BindingInfo.GetBindingInfo(new object[] { new FromQueryAttribute() }), PropertyName = "BoundProperty" }); controller.ControllerProperties.Add( new PropertyModel(controller.ControllerType.GetProperty("UnboundProperty"), new List<object>() { })); controller.Application = applicationModel; applicationModel.Controllers.Add(controller); var methodInfo = typeof(TestController).GetMethod("SomeAction"); var actionModel = new ActionModel(methodInfo, new List<object>() { }); actionModel.Controller = controller; controller.Actions.Add(actionModel); // Act var descriptors = ControllerActionDescriptorBuilder.Build(applicationModel); // Assert var property = Assert.Single(descriptors.Single().BoundProperties); Assert.Equal("BoundProperty", property.Name); Assert.Equal(typeof(string), property.ParameterType); Assert.Equal(BindingSource.Query, property.BindingInfo.BindingSource); }
public void Apply(ControllerModel controller) { if (controller == null) { throw new ArgumentNullException(nameof(controller)); } if (IsConventionApplicable(controller)) { controller.RouteConstraints.Add(new AreaAttribute(_area)); } }
public void Apply(ControllerModel model) { foreach (var action in model.Actions) { if (action.AttributeRouteModel == null) { action.AttributeRouteModel = new AttributeRouteModel(); } if (action.AttributeRouteModel.Name == null) { action.AttributeRouteModel.Name = string.Format( "{0}_{1}", model.ControllerName, action.ActionName); } } }
public ControllerModelValues(ControllerModel inner) { if (inner != null) { ControllerName = inner.ControllerName; ControllerType = inner.ControllerType.AsType(); ApiExplorer = new ApiExplorerModelValues(inner.ApiExplorer); Actions = inner.Actions.Select(a => new ActionModelValues(a)).ToList(); Attributes = inner.Attributes.Select(a => a.GetType()).ToList(); ControllerProperties = inner.ControllerProperties.Select(p => new PropertyModelValues(p)).ToList(); Filters = inner.Filters.Select(f => new FilterValues(f)).ToList(); ActionConstraints = inner.ActionConstraints?.Select(a => new ActionConstraintValues(a))?.ToList(); RouteConstraints = inner.RouteConstraints.Select( r => new RouteConstraintProviderValues(r)).ToList(); AttributeRoutes = inner.AttributeRoutes.Select( a => new AttributeRouteModelValues(a)).ToList(); Properties = new Dictionary<object, object>(inner.Properties); } }
public void Build_WithPropertiesSet_FromApplicationModel() { // Arrange var applicationModel = new ApplicationModel(); applicationModel.Properties["test"] = "application"; var controller = new ControllerModel(typeof(TestController).GetTypeInfo(), new List<object>() { }); controller.Application = applicationModel; applicationModel.Controllers.Add(controller); var methodInfo = typeof(TestController).GetMethod("SomeAction"); var actionModel = new ActionModel(methodInfo, new List<object>() { }); actionModel.Controller = controller; controller.Actions.Add(actionModel); // Act var descriptors = ControllerActionDescriptorBuilder.Build(applicationModel); // Assert Assert.Equal("application", descriptors.Single().Properties["test"]); }
public void CopyConstructor_CopiesAllProperties() { // Arrange var controller = new ControllerModel(typeof(TestController).GetTypeInfo(), new List<object>() { new HttpGetAttribute(), new AuthorizeAttribute() }); controller.ActionConstraints.Add(new HttpMethodConstraint(new string[] { "GET" })); controller.Application = new ApplicationModel(); controller.ControllerName = "cool"; controller.Filters.Add(new AuthorizeFilter(new AuthorizationPolicyBuilder().RequireClaim("whatever").Build())); controller.RouteConstraints.Add(new AreaAttribute("Admin")); controller.Properties.Add(new KeyValuePair<object, object>("test key", "test value")); controller.ControllerProperties.Add( new PropertyModel(typeof(TestController).GetProperty("TestProperty"), new List<object>())); // Act var controller2 = new ControllerModel(controller); // Assert foreach (var property in typeof(ControllerModel).GetProperties()) { if (property.Name.Equals("Actions") || property.Name.Equals("AttributeRoutes") || property.Name.Equals("ApiExplorer") || property.Name.Equals("ControllerProperties")) { // This test excludes other ApplicationModel objects on purpose because we deep copy them. continue; } var value1 = property.GetValue(controller); var value2 = property.GetValue(controller2); if (typeof(IEnumerable<object>).IsAssignableFrom(property.PropertyType)) { Assert.Equal<object>((IEnumerable<object>)value1, (IEnumerable<object>)value2); // Ensure non-default value Assert.NotEmpty((IEnumerable<object>)value1); } else if (typeof(IDictionary<object, object>).IsAssignableFrom(property.PropertyType)) { Assert.Equal(value1, value2); // Ensure non-default value Assert.NotEmpty((IDictionary<object, object>)value1); } else if (property.PropertyType.IsValueType || Nullable.GetUnderlyingType(property.PropertyType) != null) { Assert.Equal(value1, value2); // Ensure non-default value Assert.NotEqual(value1, Activator.CreateInstance(property.PropertyType)); } else { Assert.Same(value1, value2); // Ensure non-default value Assert.NotNull(value1); } } }
public void ApplyConventions_RunsInOrderOfDecreasingScope() { // Arrange var sequence = 0; var applicationConvention = new Mock<IApplicationModelConvention>(); applicationConvention .Setup(c => c.Apply(It.IsAny<ApplicationModel>())) .Callback(() => { Assert.Equal(0, sequence++); }); var controllerConvention = new Mock<IControllerModelConvention>(); controllerConvention .Setup(c => c.Apply(It.IsAny<ControllerModel>())) .Callback(() => { Assert.Equal(1, sequence++); }); var actionConvention = new Mock<IActionModelConvention>(); actionConvention .Setup(c => c.Apply(It.IsAny<ActionModel>())) .Callback(() => { Assert.Equal(2, sequence++); }); var parameterConvention = new Mock<IParameterModelConvention>(); parameterConvention .Setup(c => c.Apply(It.IsAny<ParameterModel>())) .Callback(() => { Assert.Equal(3, sequence++); }); var options = new TestOptionsManager<MvcOptions>(); options.Value.Conventions.Add(applicationConvention.Object); var applicationModel = new ApplicationModel(); var controller = new ControllerModel(typeof(ConventionsController).GetTypeInfo(), new List<object>() { controllerConvention.Object }); controller.Application = applicationModel; applicationModel.Controllers.Add(controller); var methodInfo = typeof(ConventionsController).GetMethod("Create"); var actionModel = new ActionModel(methodInfo, new List<object>() { actionConvention.Object }); actionModel.Controller = controller; controller.Actions.Add(actionModel); var parameterInfo = actionModel.ActionMethod.GetParameters().Single(); var parameterModel = new ParameterModel(parameterInfo, new List<object>() { parameterConvention.Object }); parameterModel.Action = actionModel; actionModel.Parameters.Add(parameterModel); // Act ApplicationModelConventions.ApplyConventions(applicationModel, options.Value.Conventions); // Assert Assert.Equal(4, sequence); }
public void Apply([NotNull] ControllerModel controller) { controller.Properties.Add("TestProperty", "TestValue"); }
public void Apply(ControllerModel controller) { controller.Properties["lisence"] = "Copyright (c) .NET Foundation. All rights reserved." + " Licensed under the Apache License, Version 2.0. See License.txt " + "in the project root for license information."; }
public void Apply(ControllerModel controller) { controller.ControllerName = "ChangedController"; }
public void CopyConstructor_CopiesAllProperties() { // Arrange var controller = new ControllerModel(typeof(TestController).GetTypeInfo(), new List <object>() { new HttpGetAttribute(), new AuthorizeAttribute() }); controller.ActionConstraints.Add(new HttpMethodConstraint(new string[] { "GET" })); controller.Application = new ApplicationModel(); controller.ControllerName = "cool"; controller.Filters.Add(new AuthorizeFilter(new AuthorizationPolicyBuilder().Build())); controller.RouteConstraints.Add(new AreaAttribute("Admin")); controller.Properties.Add(new KeyValuePair <object, object>("test key", "test value")); controller.ControllerProperties.Add( new PropertyModel(typeof(TestController).GetProperty("TestProperty"), new List <object>())); // Act var controller2 = new ControllerModel(controller); // Assert foreach (var property in typeof(ControllerModel).GetProperties()) { if (property.Name.Equals("Actions") || property.Name.Equals("AttributeRoutes") || property.Name.Equals("ApiExplorer") || property.Name.Equals("ControllerProperties")) { // This test excludes other ApplicationModel objects on purpose because we deep copy them. continue; } var value1 = property.GetValue(controller); var value2 = property.GetValue(controller2); if (typeof(IEnumerable <object>).IsAssignableFrom(property.PropertyType)) { Assert.Equal <object>((IEnumerable <object>)value1, (IEnumerable <object>)value2); // Ensure non-default value Assert.NotEmpty((IEnumerable <object>)value1); } else if (typeof(IDictionary <object, object>).IsAssignableFrom(property.PropertyType)) { Assert.Equal(value1, value2); // Ensure non-default value Assert.NotEmpty((IDictionary <object, object>)value1); } else if (property.PropertyType.IsValueType || Nullable.GetUnderlyingType(property.PropertyType) != null) { Assert.Equal(value1, value2); // Ensure non-default value Assert.NotEqual(value1, Activator.CreateInstance(property.PropertyType)); } else { Assert.Same(value1, value2); // Ensure non-default value Assert.NotNull(value1); } } }
private bool IsConventionApplicable(ControllerModel controller) { return controller.Attributes.OfType<IUseWebApiRoutes>().Any(); }
public void Apply(ControllerModel model) { model.ControllerName = _controllerName; }
public void Apply(ControllerModel model) { model.Properties["description"] = _value; }
public void Apply(ControllerModel controller) { controller.Properties.Add("TestProperty", "TestValue"); }