[InlineData("GET", "http://localhost/Customers(12)/NS.SpecialCustomer/NS.GetSalary()", "GetSalaryFromSpecialCustomer_12")] // call function on derived entity type
        public async Task AttriubteRouting_SelectsExpectedControllerAndAction(string method, string requestUri,
            string expectedResult)
        {
            // Arrange
            CustomersModelWithInheritance model = new CustomersModelWithInheritance();

            var controllers = new[] { typeof(CustomersController), typeof(MetadataAndServiceController), typeof(OrdersController) };
            TestAssemblyResolver resolver = new TestAssemblyResolver(new MockAssembly(controllers));

            HttpConfiguration config = new HttpConfiguration();
            config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            config.Services.Replace(typeof(IAssembliesResolver), resolver);

            config.MapODataServiceRoute("odata", "", model.Model);

            HttpServer server = new HttpServer(config);
            config.EnsureInitialized();

            HttpClient client = new HttpClient(server);
            HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(method), requestUri);

            // Act
            var response = await client.SendAsync(request);

            // Assert
            if (!response.IsSuccessStatusCode)
            {
                Assert.False(true, await response.Content.ReadAsStringAsync());
            }
            var result = await response.Content.ReadAsAsync<AttributeRoutingTestODataResponse>();
            Assert.Equal(expectedResult, result.Value);
        }

        public void ByPostShouldReturnCorrectResponse()
        {
            var controller = typeof(CategoriesController);

            var config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();
            config.Routes.MapHttpRoute(
               name: "DefaultApi",
               routeTemplate: "api/{controller}/{id}",
               defaults: new { id = RouteParameter.Optional }
            );

            config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;

            var httpServer = new HttpServer(config);
            var httpInvoker = new HttpMessageInvoker(httpServer);

            using (httpInvoker)
            {
                var request = new HttpRequestMessage
                {
                    RequestUri = new Uri("http://test.com/api/categories/1"),
                    Method = HttpMethod.Get
                };

                var result = httpInvoker.SendAsync(request, CancellationToken.None).Result;

                Assert.IsNotNull(result);
            }
        }

		public void Configuration(IAppBuilder owinAppBuilder)
        {
			ConfigureAuth(owinAppBuilder);

			// DependencyInjection config
			_container.RegisterModules(new ODataServiceModule(), new IocConfig());

			// Add Web API to the Owin pipeline
			HttpConfiguration webApiConfig = new HttpConfiguration();
#if DEBUG
			webApiConfig.EnableSystemDiagnosticsTracing();
#endif
			webApiConfig.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(_container);
			HttpServer webApiServer = new HttpServer(webApiConfig);
			EntityRepositoryConfig.ConfigureODataService(webApiServer);

			// Map routes using class attributes
			webApiConfig.MapHttpAttributeRoutes();

			owinAppBuilder.UseWebApi(webApiServer);

			// Verify that DI config is valid; and initialize everything
			_container.Verify();

        }

        public static void SimpleHelloWorldController()
        {
            using (var config = new HttpConfiguration())
            using (var server = new HttpServer(config))
            using (var client = new HttpClient(server))
            {
                TraceConfig.Register(config);

                // Controllers are identified through the routing mechanism.
                // Web API includes a convenient extension method to the
                // HttpRouteCollection type, which is exposed as the
                // HttpConfiguration.Routes property. We will use the default
                // uri template and map it using the `MapHttpRoute` extension method.
                // If you have worked with MVC, this will be very familiar.
                // In a larger project, this would most likely be defined in
                // your Global.asax or WebApiConfig.cs file.
                config.Routes.MapHttpRoute(
                    name: "Api",
                    routeTemplate: "api/{controller}"
                );

                using (var response = client.GetAsync("http://example.org/api/helloworld").Result)
                {
                    var body = response.Content.ReadAsStringAsync().Result;
                    Helpers.AssertEquality("\"Hello, ApiController!\"", body);
                }
            }
        }

        public void Log_Simple_Request_Test_Should_Log_Request_And_Response()
        {
            var config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "api/{controller}/{id}", new { id = RouteParameter.Optional });

            var dummyRepository = new DummyLoggingRepository();
            config.MessageHandlers.Add(new LoggingHandler(dummyRepository));
            config.MessageHandlers.Add(new EncodingHandler());

            var server = new HttpServer(config);
            var client = new HttpClient(new EncodingHandler(server));
            client.DefaultRequestHeaders.Clear();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            var content = new List<Contact>();
            var c = new Contact { Id = 1, Birthday = DateTime.Now.AddYears(-20) };
            content.Add(c);

            var request = new HttpRequestMessage();
            request.Content = new ObjectContent(typeof(List<Contact>), content, config.Formatters.JsonFormatter);
            client.PostAsync("http://anything/api/contacts", request.Content).ContinueWith(task =>
            {
                var response = task.Result;
                Assert.IsNotNull(response);
                Assert.AreEqual(2, dummyRepository.LogMessageCount);
                Assert.IsTrue(dummyRepository.HasRequestMessageTypeBeenReceived, "No request message has been logged");
                Assert.IsTrue(dummyRepository.HasResponseMessageTypeBeenReceived, "No Response message has been received");
            });
        }

        public void ChatHistoryShouldReturnNotFoundIfNoUsername()
        {
            var controller = typeof(MessageController);

            var config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();
            config.Routes.MapHttpRoute(
               name: "DefaultApi",
               routeTemplate: "api/{controller}/{id}",
               defaults: new { id = RouteParameter.Optional }
            );

            var httpServer = new HttpServer(config);

            var httpInvoker = new HttpMessageInvoker(httpServer);

            using (httpInvoker)
            {
                var request = new HttpRequestMessage
                {
                    RequestUri = new Uri("http://test.com/api/Message/History"),
                    Method = HttpMethod.Get
                };

                var result = httpInvoker.SendAsync(request, CancellationToken.None).Result;
                Assert.AreEqual(HttpStatusCode.NotFound, result.StatusCode);
            }
        }

        public void WindsorResolver_Resolves_Registered_ContactRepository_Through_ContactsController_Test()
        {
            var config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default",
                "api/{controller}/{id}", new { id = RouteParameter.Optional });

            using (var container = new WindsorContainer())
            {
                container.Register(
                    Component.For<IContactRepository>().Instance(new InMemoryContactRepository()),
                    Component.For<ContactsController>().ImplementedBy<ContactsController>());

                config.DependencyResolver = new WindsorResolver(container);

                var server = new HttpServer(config);
                var client = new HttpClient(server);

				client.GetAsync("http://anything/api/contacts").ContinueWith(task =>
				{
					var response = task.Result.Content.ReadAsAsync<List<Contact>>().Result;
					Assert.IsNotNull(response[1]);


				});
            }
        }

 public ODataSingletonQueryOptionTest()
 {
     _configuration = new HttpConfiguration();
     _configuration.Routes.MapODataServiceRoute("odata", "odata", GetEdmModel());
     HttpServer server = new HttpServer(_configuration);
     _client = new HttpClient(server);
 }

		/// <summary>
		/// Configure all the OWIN modules that participate in each request.
		/// </summary>
		/// <param name="app">The OWIN appBuilder</param>
		/// <remarks>
		/// The order of configuration is IMPORTANT - it sets the sequence of the request processing pipeline.
		/// </remarks>
		public void Configuration(IAppBuilder app)
		{
#if DEBUG
			// Debug builds get full call stack in error pages.
			app.Properties["host.AppMode"] = "development";
#else
			app.Properties["host.AppMode"] = "release";
#endif

			// DependencyInjection config
			var diContainer = new Container { Options = { AllowOverridingRegistrations = true } };
			diContainer.RegisterModules(new ODataServiceModule(), new AppModule());

			// Configure logging
			ConfigureOwinLogging(app, diContainer);

			// Web API config
			var webApiConfig = new HttpConfiguration();
			webApiConfig.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(diContainer);

			// Map routes using class attributes
			webApiConfig.MapHttpAttributeRoutes();

			HttpServer webApiServer = new HttpServer(webApiConfig);
			WebApiConfig.ConfigureODataService(webApiConfig, webApiServer);

			app.UseWebApi(webApiServer);
		}

        public void IndexShouldNotThrow()
        {
            var controller = typeof(ChatController);

            var config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}",
                defaults: new { id = RouteParameter.Optional }
            );

            var httpServer = new HttpServer(config);

            var httpInvoker = new HttpMessageInvoker(httpServer);

            using (httpInvoker)
            {
                var request = new HttpRequestMessage
                {
                    RequestUri = new Uri("http://test.com/api/Chat/Index"),
                    Method= HttpMethod.Get
                };

                var result=httpInvoker.SendAsync(request, CancellationToken.None).Result;

            }
        }

 public static async void RegisterTrippin(
     HttpConfiguration config, HttpServer server)
 {
     await config.MapRestierRoute<TrippinApi>(
         "TrippinApi", "api/Trippin",
         new RestierBatchHandler(server));
 }

        public static async Task<HttpResponseMessage> GetResponse(
            string requestUri,
            HttpMethod httpMethod,
            HttpContent requestContent,
            Action<HttpConfiguration, HttpServer> registerOData,
            IEnumerable<KeyValuePair<string, string>> headers = null)
        {
            using (HttpConfiguration config = new HttpConfiguration())
            {
                using (HttpServer server = new HttpServer(config))
                using (HttpMessageInvoker client = new HttpMessageInvoker(server))
                {
                    registerOData(config, server);
                    HttpRequestMessage request = new HttpRequestMessage(httpMethod, requestUri);
                    try
                    {
                        request.Content = requestContent;
                        if (headers != null)
                        {
                            foreach (var header in headers)
                            {
                                request.Headers.Add(header.Key, header.Value);
                            }
                        }

                        return await client.SendAsync(request, CancellationToken.None);
                    }
                    finally
                    {
                        request.DisposeRequestResources();
                        request.Dispose();
                    }
                }
            }
        }

 public BadClient(HttpServer server, ITestOutputHelper output)
 {
     client = new HttpClient(new RequestLogger(output, true, server), false)
     {
         BaseAddress = new Uri("http://bad-client-based")
     };
 }

        public static void BasicAuthentication()
        {
            using (var config = new HttpConfiguration())
            using (var server = new HttpServer(config))
            using (var client = new HttpClient(server))
            {
                config.Routes.MapHttpRoute(
                    name: "Api",
                    routeTemplate: "api/{controller}/{id}",
                    defaults: new {id = RouteParameter.Optional}
                );

                var authConfig = new AuthenticationConfiguration
                {
                    InheritHostClientIdentity = true,
                    ClaimsAuthenticationManager = FederatedAuthentication
                        .FederationConfiguration
                        .IdentityConfiguration
                        .ClaimsAuthenticationManager
                };

                // You can setup authentication against membership:
                //authConfig.AddBasicAuthentication((username, password) =>
                //    Membership.ValidateUser(username, password));
                authConfig.AddBasicAuthentication((username, password) =>
                    username == Helpers.__ && password == Helpers.__);

                config.MessageHandlers.Add(new AuthenticationHandler(authConfig));

                client.DefaultRequestHeaders.Authorization =
                    new BasicAuthenticationHeaderValue("happy", "holidays");
                using (var response = client.GetAsync("http://go.com/api/authenticationkoan").Result)
                    Helpers.AssertEquality(HttpStatusCode.OK, response.StatusCode);
            }
        }

        public void ByProjectShouldReturnCorrectResponse()
        {
            // Required by the HttpServer to find controller in another assembly
            var controller = typeof(CommitsController);

            var config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();
            config.Routes.MapHttpRoute(
               name: "DefaultApi",
               routeTemplate: "api/{controller}/{id}",
               defaults: new { id = RouteParameter.Optional }
            );

            config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;

            var httpServer = new HttpServer(config);
            var httpInvoker = new HttpMessageInvoker(httpServer);

            using (httpInvoker)
            {
                var request = new HttpRequestMessage
                {
                    RequestUri = new Uri("http://test.com/api/Commits/ByProject/1"),
                    Method = HttpMethod.Get
                };

                var result = httpInvoker.SendAsync(request, CancellationToken.None).Result;

                Assert.IsNotNull(result);
                Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
            }
        }

        public async Task http_post()
        {
            //arrange
            var httpConfig = new HttpConfiguration();
            WebApiConfig.Register(httpConfig);
            var url = "http://localhost/api/default";

            //act
            using (var httpServer = new HttpServer(httpConfig))
            using (var client = new HttpMessageInvoker(httpServer))
            {
                using (var request = new HttpRequestMessage(HttpMethod.Post, url))
                {
                    request.Content = new ObjectContent<string>("Johnny", new JsonMediaTypeFormatter());
                    using (var response = await client.SendAsync(request, CancellationToken.None))
                    {
                        var output = await response.Content.ReadAsAsync<string>();

                        //assert
                        Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
                        Assert.AreEqual("Hello Johnny!", output);
                    }
                }
            }
            
        }

 public static void RegisterNorthwind(
     HttpConfiguration config, HttpServer server)
 {
     config.MapRestierRoute<NorthwindApi>(
         "NorthwindApi", "api/Northwind",
         new RestierBatchHandler(server));
 }

 public SensorRoutingTests()
 {
     configuration = new HttpConfiguration();
     configuration.MapSensorRoutes(ctx => true);
     var server = new HttpServer(configuration);
     apiClient = new HttpClient(server);
 }

        public void cache_singleton_in_pipeline()
        {
            _cache = new Mock<IApiOutputCache>();

            var conf = new HttpConfiguration();
            conf.CacheOutputConfiguration().RegisterCacheOutputProvider(() => _cache.Object);

            conf.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );

            _server = new HttpServer(conf);

            var client = new HttpClient(_server);
            var result = client.GetAsync(_url + "Get_c100_s100").Result;

            _cache.Verify(s => s.Contains(It.Is<string>(x => x == "webapi.outputcache.v2.tests.testcontrollers.samplecontroller-get_c100_s100:application/json; charset=utf-8")), Times.Exactly(2));

            var result2 = client.GetAsync(_url + "Get_c100_s100").Result;
            _cache.Verify(s => s.Contains(It.Is<string>(x => x == "webapi.outputcache.v2.tests.testcontrollers.samplecontroller-get_c100_s100:application/json; charset=utf-8")), Times.Exactly(4));

            _server.Dispose();
        }

 public SensorErrorTests()
 {
     var configuration1 = new HttpConfiguration();
     configuration1.MapSensorRoutes(ctx => true);
     var server = new HttpServer(configuration1);
     apiClient = new HttpClient(server);
 }