Пример #1
0
 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;
        }
Пример #4
0
        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);
        }
Пример #11
0
 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);
		}
Пример #13
0
        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);
        }
Пример #14
0
 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));
 }
Пример #33
0
        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))));
 }
Пример #37
0
 public System.Linq.ILookup <string, HttpActionDescriptor> GetActionMapping(HttpControllerDescriptor controllerDescriptor)
 {
     return(_concreteSelector.GetActionMapping(controllerDescriptor));
 }