public IHttpController Create( HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType ) { if ( controllerType == null ) { return null; } return this.resolver( controllerType ) as IHttpController; }
public UpshotControllerDescription(HttpControllerDescriptor controllerDescriptor) { HashSet<Type> entityTypes = new HashSet<Type>(); _upshotControllerType = controllerDescriptor.ControllerType; IEnumerable<MethodInfo> enumerable = from p in _upshotControllerType.GetMethods(BindingFlags.Instance | BindingFlags.Public) where p.DeclaringType != typeof(UpshotController) && p.DeclaringType != typeof(object) && !p.IsSpecialName select p; foreach (MethodInfo current in enumerable) { if (current.GetCustomAttributes(typeof(NonActionAttribute), false).Length <= 0 && (!current.IsVirtual || !(current.GetBaseDefinition().DeclaringType == typeof(UpshotController)))) { if (current.ReturnType != typeof(void)) { Type type = TypeUtility.UnwrapTaskInnerType(current.ReturnType); Type elementType = TypeUtility.GetElementType(type); if (LookUpIsEntityType(elementType)) { if (!entityTypes.Contains(elementType)) { entityTypes.Add(elementType); } } } } } _entityTypes = new ReadOnlyCollection<Type>(entityTypes.ToList()); }
public IHttpController Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType) { var controller = (IHttpController)this.container.GetService(controllerType); return controller; }
public IHttpController Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType) { var controller = (IHttpController)_container.Resolve(controllerType); request.RegisterForDispose(new Release(() => _container.Release(controller))); return controller; }
public virtual void Initialize(HttpControllerSettings settings, HttpControllerDescriptor descriptor) { var toRemove = settings.Formatters.Where(t => t is JsonMediaTypeFormatter || t is XmlMediaTypeFormatter).ToList(); foreach (var r in toRemove) { settings.Formatters.Remove(r); } settings.Formatters.Add(new SkybrudJsonMediaTypeFormatter()); }
public void Setting_CustomActionInvoker() { // Arrange ApiController api = new UsersController(); string responseText = "Hello World"; HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(); HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersController)); controllerContext.ControllerDescriptor = controllerDescriptor; Mock<IHttpActionInvoker> mockInvoker = new Mock<IHttpActionInvoker>(); mockInvoker .Setup(invoker => invoker.InvokeActionAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>())) .Returns(() => { TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>(); tcs.TrySetResult(new HttpResponseMessage() { Content = new StringContent(responseText) }); return tcs.Task; }); controllerDescriptor.Configuration.Services.Replace(typeof(IHttpActionInvoker), mockInvoker.Object); // Act HttpResponseMessage message = api.ExecuteAsync( controllerContext, CancellationToken.None).Result; // Assert Assert.Equal(responseText, message.Content.ReadAsStringAsync().Result); }
public void Initialize_Calls_MobileAppControllerConfigProvider_Then_TableControllerConfigProvider() { // Arrange HttpConfiguration config = new HttpConfiguration(); HttpControllerSettings settings = new HttpControllerSettings(config); HttpControllerDescriptor descriptor = new HttpControllerDescriptor() { Configuration = config }; string output = string.Empty; Mock<IMobileAppControllerConfigProvider> configProviderMock = new Mock<IMobileAppControllerConfigProvider>(); configProviderMock.Setup(p => p.Configure(settings, descriptor)).Callback(() => output += "1"); config.SetMobileAppControllerConfigProvider(configProviderMock.Object); Mock<ITableControllerConfigProvider> tableConfigProviderMock = new Mock<ITableControllerConfigProvider>(); tableConfigProviderMock.Setup(p => p.Configure(settings, descriptor)).Callback(() => output += "2"); config.SetTableControllerConfigProvider(tableConfigProviderMock.Object); // Act new TableControllerConfigAttribute().Initialize(settings, descriptor); // Assert configProviderMock.VerifyAll(); tableConfigProviderMock.VerifyAll(); Assert.Equal("12", output); }
/// <summary> /// Create a new controller based on the parameters provided, allows DI. /// </summary> /// <param name="request">The HTTP request.</param> /// <param name="controllerDescriptor">The controller descriptor.</param> /// <param name="controllerType">The type of the controller.</param> /// <returns>A new controller based on the parameters provided.</returns> public IHttpController Create( HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType) { IHttpController controller = null; PlayCustomerMigration databaseContext = null; // Create appropriate controller based on the controller name switch (controllerDescriptor.ControllerName) { case "Customer": databaseContext = new PlayCustomerMigration(); controller = new CustomerController( new VerifyCustomer( new GetCustomerFromDatabase(databaseContext), new HashEmailAddress(), new UpdateFirstLoginDate(databaseContext), new VerifyPassword())); break; } return controller; }
public static DataControllerDescription GetDescription(HttpControllerDescriptor controllerDescriptor) { return _descriptionMap.GetOrAdd(controllerDescriptor.ControllerType, type => { return CreateDescription(controllerDescriptor); }); }
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); }
IReadOnlyList<RouteEntry> IDirectRouteProvider.GetDirectRoutes(HttpControllerDescriptor controllerDescriptor, IReadOnlyList<HttpActionDescriptor> actionDescriptors, IInlineConstraintResolver constraintResolver) { var routes = _provider.GetDirectRoutes(controllerDescriptor, actionDescriptors, constraintResolver); var list = new List<RouteEntry>(); foreach (var route in routes) { var newRoute = new RouteEntry(route.Name ?? Guid.NewGuid().ToString(), route.Route); list.Add(newRoute); var descs = route.Route.GetTargetActionDescriptors(); if (descs.Length == 0) { continue; } foreach (var desc in descs) { var reflDesc = desc as ReflectedHttpActionDescriptor; if (reflDesc == null) { continue; } var method = reflDesc.MethodInfo; RouteEntry prevEntry; if (_map.TryGetValue(method, out prevEntry)) { throw new MultipleRoutesForSameMethodException(reflDesc, prevEntry, newRoute); } _map.Add(method, newRoute); } } return list; }
/// <summary> /// Callback invoked to set per-controller overrides for this controllerDescriptor. /// </summary> /// <param name="controllerSettings">The controller settings to initialize.</param> /// <param name="controllerDescriptor">The controller descriptor. Note that the <see /// cref="T:System.Web.Http.Controllers.HttpControllerDescriptor" /> can be associated with the derived /// controller type given that <see cref="T:System.Web.Http.Controllers.IControllerConfiguration" /> is /// inherited.</param> public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor) { if (controllerSettings == null) { throw new ArgumentNullException("controllerSettings"); } if (controllerDescriptor == null) { throw new ArgumentNullException("controllerDescriptor"); } ServicesContainer services = controllerSettings.Services; Contract.Assert(services != null); IContainerMetadata containerMetadata = controllerDescriptor.GetContainerMetadata(); // Replace the action selector with one that is based on the OData routing conventions IHttpActionSelector originalActionSelector = services.GetActionSelector(); IHttpActionSelector actionSelector; if (containerMetadata != null) { // ContainerMetadata was stored with the HttpControllerDescriptor - so use our "special" ActionSelector actionSelector = new EntityRepositoryActionSelector(containerMetadata, originalActionSelector); } else { // No ContainerMetadata stored with the HttpControllerDescriptor - so use the standard odata ActionSelector actionSelector = new ODataActionSelector(originalActionSelector); } controllerSettings.Services.Replace(typeof(IHttpActionSelector), actionSelector); }
public override ILookup<string, HttpActionDescriptor> GetActionMapping(HttpControllerDescriptor controllerDescriptor) { if(controllerDescriptor.ControllerType == typeof(SlimApiGhostController)) { var newActions = new List<HttpActionDescriptor>(); foreach(var contrInfo in _apiConfig.ControllerInfos) { var methods = contrInfo.Type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); foreach(var method in methods) { var dtype = method.DeclaringType; if (dtype == typeof(object)) //skip ToString() continue; var action = new SlimApiActionDescriptor(controllerDescriptor, method, contrInfo, _apiConfig); if (action.RouteTemplates.Count > 0 && action.SupportedHttpMethods.Count > 0) { RegisterAction(action); newActions.Add(action); } } } //foreach ct var lkp = newActions.ToLookup(a => a.ActionName, StringComparer.OrdinalIgnoreCase); return lkp; } // otherwise call base return base.GetActionMapping(controllerDescriptor); }
public IHttpController Create(HttpRequestMessage request , HttpControllerDescriptor controllerDescriptor, Type controllerType) { var controller = _container.GetInstance(controllerType) as IHttpController; return controller; }
/// <summary>Initializes a new instance of the <see cref="HttpControllerContext"/> class.</summary> /// <param name="requestContext">The request context.</param> /// <param name="request">The HTTP request.</param> /// <param name="controllerDescriptor">The controller descriptor.</param> /// <param name="controller">The controller.</param> public HttpControllerContext(HttpRequestContext requestContext, HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, IHttpController controller) { if (requestContext == null) { throw Error.ArgumentNull("requestContext"); } if (request == null) { throw Error.ArgumentNull("request"); } if (controllerDescriptor == null) { throw Error.ArgumentNull("controllerDescriptor"); } if (controller == null) { throw Error.ArgumentNull("controller"); } _requestContext = requestContext; _request = request; _controllerDescriptor = controllerDescriptor; _controller = controller; }
public void SelectAction_WithDirectRoutes_RespectsRouteOrder() { // 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("order", 1); ReflectedHttpActionDescriptor secondDirectRouteAction = (ReflectedHttpActionDescriptor)actionSelector.GetActionMapping(controllerDescriptor)["GetB"].Single(); subRouteData[1].Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { secondDirectRouteAction }); subRouteData[1].Route.DataTokens.Add("order", 2); // Act HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(context); // Assert Assert.Same(secondDirectRouteAction, actionDescriptor); }
/// <summary> /// Gets the documentation based on <see cref="System.Web.Http.Controllers.HttpControllerDescriptor"/>. /// </summary> /// <param name="controllerDescriptor">The controller descriptor.</param> /// <returns>The documentation for the controller.</returns> public string GetDocumentation(HttpControllerDescriptor controllerDescriptor) { return this.sources .Select(source => source.GetDocumentation(controllerDescriptor)) .Where(documentation => !string.IsNullOrEmpty(documentation)) .FirstOrDefault(); }
public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor) { controllerSettings.ParameterBindingRules.Insert(0, new Func<HttpParameterDescriptor, HttpParameterBinding>( d => new SimplePostVariableParameterBinding(d))); }
public void ShouldExploreController_MatchesRouteConstraint(bool match) { // Arrange var config = new HttpConfiguration(); var ctrlDesc = new HttpControllerDescriptor(config, "sample", typeof(SampleController)); var explorer = new MobileAppApiExplorer(config); var constraintMock = new Mock<IHttpRouteConstraint>(); var constraint = constraintMock.Object; var routeMock = new Mock<IHttpRoute>(); routeMock.Setup(r => r.Constraints); var route = routeMock.Object; constraintMock.Setup(c => c.Match(null, route, "controller", It.IsAny<IDictionary<string, object>>(), HttpRouteDirection.UriResolution)) .Returns(match) .Callback<HttpRequestMessage, IHttpRoute, string, IDictionary<string, object>, HttpRouteDirection>((req, rt, p, cnts, rd) => { Assert.Equal("sample", cnts["controller"]); }); routeMock.Setup(r => r.Constraints) .Returns(new Dictionary<string, object> { { "controller", constraint } }); // Act bool actual = explorer.ShouldExploreController("sample", ctrlDesc, route); // Assert Assert.Equal(match, actual); }
public void WrapperResolvesAuthenticationFilterFromDependencyScope() { var builder = new ContainerBuilder(); builder.Register<ILogger>(c => new Logger()).InstancePerDependency(); var activationCount = 0; builder.Register<IAutofacAuthenticationFilter>(c => new TestAuthenticationFilter(c.Resolve<ILogger>())) .AsWebApiAuthenticationFilterFor<TestController>(c => c.Get()) .InstancePerRequest() .OnActivated(e => activationCount++); var container = builder.Build(); var resolver = new AutofacWebApiDependencyResolver(container); var configuration = new HttpConfiguration { DependencyResolver = resolver }; var requestMessage = new HttpRequestMessage(); requestMessage.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, configuration); var contollerContext = new HttpControllerContext { Request = requestMessage }; var controllerDescriptor = new HttpControllerDescriptor { ControllerType = typeof(TestController) }; var methodInfo = typeof(TestController).GetMethod("Get"); var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo); var actionContext = new HttpActionContext(contollerContext, actionDescriptor); var context = new HttpAuthenticationContext(actionContext, Thread.CurrentPrincipal); var metadata = new FilterMetadata { ControllerType = typeof(TestController), FilterScope = FilterScope.Action, MethodInfo = methodInfo }; var wrapper = new AuthenticationFilterWrapper(metadata); wrapper.OnAuthenticate(context); Assert.That(activationCount, Is.EqualTo(1)); }
/// <summary> /// This method is called by Web API system to select the controller for this request. /// </summary> /// <param name="request">Request object</param> /// <returns>The controller to be used</returns> public override HttpControllerDescriptor SelectController(HttpRequestMessage request) { if (request != null) { var routeData = request.GetRouteData(); if (routeData != null) { string serviceName; if (routeData.Values.TryGetValue("serviceName", out serviceName)) { string areaName; if (routeData.Values.TryGetValue("areaName", out areaName)) { var controllerName = areaName.ToPascalCase() + "/" + serviceName.ToPascalCase(); var controllerInfo = DynamicApiControllerManager.Find(controllerName); if (controllerInfo != null) { var controllerDescriptor = new HttpControllerDescriptor(_configuration, controllerInfo.Name, controllerInfo.Type); controllerDescriptor.Properties["__AbpDynamicApiControllerInfo"] = controllerInfo; return controllerDescriptor; } } } } } return base.SelectController(request); }
/// <inheritdoc /> public virtual void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor) { if (controllerSettings == null) { throw new ArgumentNullException("controllerSettings"); } JsonMediaTypeFormatter jsonFormatter = new JsonMediaTypeFormatter(); JsonSerializerSettings serializerSettings = jsonFormatter.SerializerSettings; // Set up date/time format to be ISO 8601 but with 3 digits and "Z" as UTC time indicator. This format // is the JS-valid format accepted by most JS clients. IsoDateTimeConverter dateTimeConverter = new IsoDateTimeConverter() { Culture = CultureInfo.InvariantCulture, DateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFZ", DateTimeStyles = DateTimeStyles.AdjustToUniversal }; // Ignoring default values while serializing was affecting offline scenarios as client sdk looks at first object in a batch for the properties. // If first row in the server response did not include columns with default values, client sdk ignores these columns for the rest of the rows serializerSettings.DefaultValueHandling = DefaultValueHandling.Include; serializerSettings.NullValueHandling = NullValueHandling.Include; serializerSettings.Converters.Add(new StringEnumConverter()); serializerSettings.Converters.Add(dateTimeConverter); serializerSettings.MissingMemberHandling = MissingMemberHandling.Error; serializerSettings.CheckAdditionalContent = true; serializerSettings.ContractResolver = new ServiceContractResolver(jsonFormatter); controllerSettings.Formatters.Remove(controllerSettings.Formatters.JsonFormatter); controllerSettings.Formatters.Insert(0, jsonFormatter); }
IHttpController IHttpControllerActivator.Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType) { IHttpController controller = null; _traceWriter.TraceBeginEnd( request, TraceCategories.ControllersCategory, TraceLevel.Info, _innerActivator.GetType().Name, CreateMethodName, beginTrace: null, execute: () => { controller = _innerActivator.Create(request, controllerDescriptor, controllerType); }, endTrace: (tr) => { tr.Message = controller == null ? SRResources.TraceNoneObjectMessage : controller.GetType().FullName; }, errorTrace: null); if (controller != null && !(controller is HttpControllerTracer)) { controller = new HttpControllerTracer(request, controller, _traceWriter); } return controller; }
/// <inheritdoc /> public void Configure(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor) { if (controllerSettings == null) { throw new ArgumentNullException("controllerSettings"); } if (controllerDescriptor == null) { throw new ArgumentNullException("controllerDescriptor"); } // We need to remove the xml formatter because it cannot handle the wrapped // results this controller produces for inline count, etc. controllerSettings.Formatters.Remove(controllerSettings.Formatters.XmlFormatter); // Add additional query related filters for the same actions with a QueryableAttribute // The Filter Provider ensures that the additional filters are always *after* the query filter as we // want the IQueryable to have been set up before we do additional work on it. controllerSettings.Services.Add(typeof(IFilterProvider), new TableFilterProvider()); // Register a ContractResolver with the JSON formatter that can handle Delta<T> correctly JsonMediaTypeFormatter jsonFormatter = controllerSettings.Formatters.JsonFormatter; jsonFormatter.SerializerSettings.ContractResolver = new TableContractResolver(jsonFormatter); }
public IHttpController Create(System.Net.Http.HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType) { return System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver .GetService(controllerType) as IHttpController; }
IHttpController IHttpControllerActivator.Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType) { IHttpController controller; if (controllerType == null) throw new HttpException( 404, String.Format( "The controller for path '{0}' could not be found" + "or it does not implement IController.", request.RequestUri.PathAndQuery)); if (!typeof(IHttpController).IsAssignableFrom(controllerType)) throw new ArgumentException( string.Format( "Type requested is not a controller: {0}", controllerType.Name), "controllerType"); try { controller = BusinessLogic.Core.UnityConfig.Container.Resolve(controllerType, controllerType.Name) as IHttpController; } catch (Exception ex) { throw new InvalidOperationException(String.Format( "Error resolving controller {0}", controllerType.Name), ex); } return controller; }
public UpdateActionDescriptor(HttpControllerDescriptor controllerDescriptor, MethodInfo method, Type entityType, ChangeOperation operationType) : base(controllerDescriptor, method) { _entityType = entityType; _changeOperation = operationType; _method = method; }
private ActionSelectorCacheItem GetInternalSelector(HttpControllerDescriptor controllerDescriptor) { // Performance-sensitive // First check in the local fast cache and if not a match then look in the broader // HttpControllerDescriptor.Properties cache if (_fastCache == null) { ActionSelectorCacheItem selector = new ActionSelectorCacheItem(controllerDescriptor); Interlocked.CompareExchange(ref _fastCache, selector, null); return selector; } else if (_fastCache.HttpControllerDescriptor == controllerDescriptor) { // If the key matches and we already have the delegate for creating an instance then just execute it return _fastCache; } else { // If the key doesn't match then lookup/create delegate in the HttpControllerDescriptor.Properties for // that HttpControllerDescriptor instance object cacheValue; if (controllerDescriptor.Properties.TryGetValue(_cacheKey, out cacheValue)) { return (ActionSelectorCacheItem)cacheValue; } // Race condition on initialization has no side effects ActionSelectorCacheItem selector = new ActionSelectorCacheItem(controllerDescriptor); controllerDescriptor.Properties.TryAdd(_cacheKey, selector); return selector; } }
public void Setting_CustomActionSelector() { // Arrange ApiController api = new UsersController(); HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(); HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersController)); controllerContext.ControllerDescriptor = controllerDescriptor; Mock<IHttpActionSelector> mockSelector = new Mock<IHttpActionSelector>(); mockSelector .Setup(invoker => invoker.SelectAction(It.IsAny<HttpControllerContext>())) .Returns(() => { Func<HttpResponseMessage> testDelegate = () => new HttpResponseMessage { Content = new StringContent("This is a test") }; return new ReflectedHttpActionDescriptor { Configuration = controllerContext.Configuration, ControllerDescriptor = controllerDescriptor, MethodInfo = testDelegate.Method }; }); controllerDescriptor.Configuration.Services.Replace(typeof(IHttpActionSelector), mockSelector.Object); // Act HttpResponseMessage message = api.ExecuteAsync( controllerContext, CancellationToken.None).Result; // Assert Assert.Equal("This is a test", message.Content.ReadAsStringAsync().Result); }
public void GetBinding_Invokes_Inner_And_Returns_ActionBinder_With_Tracing_FormatterParameterBinding() { // Arrange Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true }; mockActionDescriptor.Setup(a => a.ActionName).Returns("test"); mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0])); Mock<HttpParameterDescriptor> mockParameterDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true }; Mock<FormatterParameterBinding> mockParameterBinding = new Mock<FormatterParameterBinding>(mockParameterDescriptor.Object, new MediaTypeFormatterCollection(), null) { CallBase = true }; HttpActionBinding actionBinding = new HttpActionBinding(mockActionDescriptor.Object, new HttpParameterBinding[] { mockParameterBinding.Object }); HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "controller", typeof(ApiController)); HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage()); controllerContext.ControllerDescriptor = controllerDescriptor; Mock<IActionValueBinder> mockBinder = new Mock<IActionValueBinder>() { CallBase = true }; mockBinder.Setup(b => b.GetBinding(It.IsAny<HttpActionDescriptor>())).Returns(actionBinding); ActionValueBinderTracer tracer = new ActionValueBinderTracer(mockBinder.Object, new TestTraceWriter()); // Act HttpActionBinding actualBinding = ((IActionValueBinder)tracer).GetBinding(mockActionDescriptor.Object); // Assert Assert.IsAssignableFrom<FormatterParameterBindingTracer>(actualBinding.ParameterBindings[0]); }
public IHttpController Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType) { return((IHttpController)_container.GetInstance(controllerType)); }
public ILookup <string, HttpActionDescriptor> GetActionMapping(HttpControllerDescriptor controllerDescriptor) { return(_innerSelector.GetActionMapping(controllerDescriptor)); }
public string GetDocumentation(HttpControllerDescriptor controllerDescriptor) { XPathNavigator typeNode = GetTypeNode(controllerDescriptor.ControllerType); return(GetTagValue(typeNode, "summary")); }
public DyanamicHttpActionDescriptor(HttpControllerDescriptor controllerDescriptor, MethodInfo methodInfo, IFilter[] filters = null) : base(controllerDescriptor, methodInfo) { _filters = filters; }
public virtual void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor) { controllerSettings.Services.Add(typeof(IExceptionLogger), new UnhandledExceptionLogger()); }
public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor) { controllerSettings.Services.Replace(typeof(IHttpActionSelector), new ParameterSwapControllerActionSelector( new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetNiceUrl", "id", typeof(int), typeof(Guid), typeof(Udi)))); }
public System.Linq.ILookup <string, HttpActionDescriptor> GetActionMapping(HttpControllerDescriptor controllerDescriptor) { return(_concreteSelector.GetActionMapping(controllerDescriptor)); }