/// <summary>
/// Scans the calling assembly for all routes defined with AttributeRouting attributes,
/// using the default conventions.
/// </summary>
public static void MapHttpAttributeRoutes(this HttpRouteCollection routes)
{
var configuration = new HttpConfiguration();
configuration.AddRoutesFromAssembly(Assembly.GetCallingAssembly());
routes.MapHttpAttributeRoutesInternal(configuration);
}
public QueryableLimitationTest()
{
_configuration = new HttpConfiguration();
_configuration.Routes.MapODataRoute("odata", "odata", GetEdmModel());
HttpServer server = new HttpServer(_configuration);
_client = new HttpClient(server);
}
public void BadReturnTypeThrows(string methodName)
{
// Arrange
ODataQueryParameterBindingAttribute attribute = new ODataQueryParameterBindingAttribute();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/Customer/?$orderby=Name");
HttpConfiguration config = new HttpConfiguration();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
HttpControllerContext controllerContext = new HttpControllerContext(config, new HttpRouteData(new HttpRoute()), request);
HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "CustomerLowLevel", typeof(CustomerHighLevelController));
MethodInfo methodInfo = typeof(CustomerLowLevelController).GetMethod(methodName);
ParameterInfo parameterInfo = methodInfo.GetParameters().First();
HttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
HttpActionContext actionContext = new HttpActionContext(controllerContext, actionDescriptor);
HttpParameterDescriptor parameterDescriptor = new ReflectedHttpParameterDescriptor(actionDescriptor, parameterInfo);
// Act
HttpParameterBinding binding = attribute.GetBinding(parameterDescriptor);
// Act & Assert
Assert.Throws<InvalidOperationException>(
() => binding.ExecuteBindingAsync((ModelMetadataProvider)null, actionContext, CancellationToken.None).Wait(),
String.Format(
"The 'ODataQueryParameterBinding' type cannot be used with action '{0}' on controller 'CustomerLowLevel' because the return type '{1}' does not specify the type of the collection.",
actionDescriptor.ActionName,
actionDescriptor.ReturnType.FullName));
}
/// <summary>
/// Scans the specified assemblies for all routes defined with AttributeRouting attributes,
/// and applies configuration options against the routes found.
/// </summary>
/// <param name="routes"></param>
/// <param name="configurationAction">The initialization action that builds the configuration object</param>
public static void MapHttpAttributeRoutes(this HttpRouteCollection routes, Action<HttpConfiguration> configurationAction)
{
var configuration = new HttpConfiguration();
configurationAction.Invoke(configuration);
routes.MapHttpAttributeRoutesInternal(configuration);
}
public void SendAsync_CallsControllerExecuteAsyncWithPopulatedControllerContext()
{
HttpControllerContext calledContext = null;
var mockSelector = new Mock<IHttpControllerSelector>();
var mockDescriptor = new Mock<HttpControllerDescriptor>();
var mockController = new Mock<IHttpController>();
var config = new HttpConfiguration();
config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
var request = CreateRequest(config, "http://localhost/api/foo");
mockSelector.Setup(s => s.SelectController(request))
.Returns(mockDescriptor.Object);
mockDescriptor.Setup(d => d.CreateController(request))
.Returns(mockController.Object);
mockDescriptor.Object.Initialize(config);
mockController.Setup(c => c.ExecuteAsync(It.IsAny<HttpControllerContext>(), CancellationToken.None))
.Callback((HttpControllerContext ctxt, CancellationToken token) => { calledContext = ctxt; });
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
invoker.SendAsync(request, CancellationToken.None).WaitUntilCompleted();
Assert.NotNull(calledContext);
Assert.Same(mockController.Object, calledContext.Controller);
Assert.Same(mockDescriptor.Object, calledContext.ControllerDescriptor);
Assert.Same(config, calledContext.Configuration);
Assert.Same(request, calledContext.Request);
Assert.Same(request.GetRouteData(), calledContext.RouteData);
}
public void EnumParameters_ShowUpCorrectlyOnDescription()
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute("Default", "{controller}");
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(EnumParameterOverloadsController));
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetWithEnumParameter");
Assert.NotNull(description);
Assert.Equal(1, description.ParameterDescriptions.Count);
Assert.Equal(ApiParameterSource.FromUri, description.ParameterDescriptions[0].Source);
Assert.Equal("EnumParameterOverloads?scope={scope}", description.RelativePath);
description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetWithTwoEnumParameters");
Assert.NotNull(description);
Assert.Equal(2, description.ParameterDescriptions.Count);
Assert.Equal(ApiParameterSource.FromUri, description.ParameterDescriptions[0].Source);
Assert.Equal(ApiParameterSource.FromUri, description.ParameterDescriptions[1].Source);
Assert.Equal("EnumParameterOverloads?level={level}&kind={kind}", description.RelativePath);
description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetWithNullableEnumParameter");
Assert.NotNull(description);
Assert.Equal(1, description.ParameterDescriptions.Count);
Assert.Equal(ApiParameterSource.FromUri, description.ParameterDescriptions[0].Source);
Assert.Equal("EnumParameterOverloads?level={level}", description.RelativePath);
}
private static HttpRequestMessage GetSampleRequest()
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/property");
HttpConfiguration config = new HttpConfiguration();
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
return request;
}
private static void UseWebApi(IAppBuilder application, IKernel kernel)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
var cors = new EnableCorsAttribute("*", "*", "*");
//GlobalConfiguration.Configure(configuration =>
//{
// configuration.SuppressDefaultHostAuthentication();
// configuration.MapHttpAttributeRoutes();
// configuration.EnableCors(cors);
// configuration.Filters.Add(new HostAuthenticationAttribute(OAuthDefaults.AuthenticationType));
// var jsonformatter = configuration.Formatters.JsonFormatter;
// jsonformatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
// configuration.AddJsonpFormatter();
// application.UseNinjectMiddleware(() => kernel);
// application.UseNinjectWebApi(configuration);
// application.UseWebApi(configuration);
//});
config.SuppressDefaultHostAuthentication();
ConfigureOAuth(application);
config.EnableCors(cors);
config.Filters.Add(new HostAuthenticationAttribute(OAuthDefaults.AuthenticationType));
var jsonformatter = config.Formatters.JsonFormatter;
jsonformatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.AddJsonpFormatter();
application.UseNinjectMiddleware(() => kernel);
application.UseNinjectWebApi(config);
application.UseWebApi(config);
application.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
}
public void NavigationLinksGenerationConvention_GeneratesLinksWithCast_ForDerivedProperties()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Vehicle>("vehicles");
builder.EntitySet<Manufacturer>("manufacturers");
IEdmModel model = builder.GetEdmModel();
IEdmEntitySet vehiclesEdmEntitySet = model.EntityContainers().Single().FindEntitySet("vehicles");
IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));
IEdmNavigationProperty carManufacturerProperty = carType.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.Routes.MapODataServiceRoute(routeName, null, model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.SetConfiguration(configuration);
request.ODataProperties().RouteName = routeName;
EntitySetLinkBuilderAnnotation linkBuilder = model.GetEntitySetLinkBuilder(vehiclesEdmEntitySet);
var serializerContext = new ODataSerializerContext { Model = model, EntitySet = vehiclesEdmEntitySet, Url = request.GetUrlHelper() };
var entityContext = new EntityInstanceContext(serializerContext, carType.AsReference(), new Car { Model = 2009, Name = "Accord" });
Uri uri = linkBuilder.BuildNavigationLink(entityContext, carManufacturerProperty, ODataMetadataLevel.Default);
Assert.Equal("http://localhost/vehicles(Model=2009,Name='Accord')/System.Web.Http.OData.Builder.TestModels.Car/Manufacturer", uri.AbsoluteUri);
}
public void GetEdmModelReturnsNullByDefault()
{
HttpConfiguration config = new HttpConfiguration();
IEdmModel model = config.GetEdmModel();
Assert.Null(model);
}
public void NavigationLinksGenerationConvention_GeneratesLinksWithCast_ForDerivedProperties()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Vehicle>("vehicles");
builder.EntitySet<Manufacturer>("manufacturers");
IEdmModel model = builder.GetEdmModel();
IEdmEntitySet vehiclesEdmEntitySet = model.EntityContainers().Single().FindEntitySet("vehicles");
IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));
IEdmNavigationProperty carManufacturerProperty = carType.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);
HttpConfiguration configuration = new HttpConfiguration();
configuration.EnableOData(model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute());
IEntitySetLinkBuilder linkBuilder = model.GetEntitySetLinkBuilder(vehiclesEdmEntitySet);
Uri uri = linkBuilder.BuildNavigationLink(
new EntityInstanceContext()
{
EdmModel = model,
EntitySet = vehiclesEdmEntitySet,
EntityType = carType,
UrlHelper = request.GetUrlHelper(),
PathHandler = new DefaultODataPathHandler(model),
EntityInstance = new Car { Model = 2009, Name = "Accord" }
},
carManufacturerProperty);
Assert.Equal("http://localhost/vehicles(Model=2009,Name='Accord')/System.Web.Http.OData.Builder.TestModels.Car/Manufacturer", uri.AbsoluteUri);
}
public void Apply_Doesnot_Override_UserConfiguration()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var vehicles = builder.EntitySet<Vehicle>("vehicles");
var car = builder.AddEntity(typeof(Car));
var paintAction = vehicles.EntityType.Action("Paint");
paintAction.HasActionLink(ctxt => new Uri("http://localhost/ActionTestWorks"), followsConventions: false);
ActionLinkGenerationConvention convention = new ActionLinkGenerationConvention();
convention.Apply(paintAction, builder);
IEdmModel model = builder.GetEdmModel();
var vehiclesEdmSet = model.EntityContainers().Single().FindEntitySet("vehicles");
var carEdmType = model.FindDeclaredType("System.Web.Http.OData.Builder.TestModels.Car") as IEdmEntityType;
var paintEdmAction =
model.GetAvailableProcedures(
model.FindDeclaredType("System.Web.Http.OData.Builder.TestModels.Car") as IEdmEntityType).Single()
as IEdmAction;
Assert.NotNull(paintEdmAction);
HttpConfiguration configuration = new HttpConfiguration();
configuration.Routes.MapODataRoute(model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.SetConfiguration(configuration);
ActionLinkBuilder actionLinkBuilder = model.GetActionLinkBuilder(paintEdmAction);
var serializerContext = new ODataSerializerContext { Model = model, EntitySet = vehiclesEdmSet, Url = request.GetUrlHelper() };
var entityContext = new EntityInstanceContext(serializerContext, carEdmType.AsReference(), new Car { Model = 2009, Name = "Accord" });
Uri link = actionLinkBuilder.BuildActionLink(entityContext);
Assert.Equal("http://localhost/ActionTestWorks", link.AbsoluteUri);
}
public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
// map the MVC UI route (note the route constraint as the last controller passed in)
// http://codebetter.com/howarddierking/2011/05/09/using-serviceroute-with-existing-mvc-routes/
routes.MapRoute(
"Default", // Route name
"{controller}/{action}/{id}", // URL with parameters
new { controller = "Dashboard", action = "Home", id = UrlParameter.Optional }, // Parameter defaults
new { controller = new NotInValuesConstraint(new[] { "constants", "folders", "items", "itemtypes", "operations", "speech", "suggestions", "tags", "trace", "users", "OAuthHandler.ashx" }) }
);
// map the WCF WebApi service routes
HttpConfiguration config = new HttpConfiguration() { MaxBufferSize = 1024 * 1024, MaxReceivedMessageSize = 1024 * 1024 };
RouteTable.Routes.MapServiceRoute<ConstantsResource>("constants", null);
RouteTable.Routes.MapServiceRoute<FolderResource>("folders", null);
RouteTable.Routes.MapServiceRoute<ItemResource>("items", config);
RouteTable.Routes.MapServiceRoute<ItemTypeResource>("itemtypes", null);
RouteTable.Routes.MapServiceRoute<OperationResource>("operations", null);
RouteTable.Routes.MapServiceRoute<SpeechResource>("speech",
new HttpConfiguration
{
MaxReceivedMessageSize = 1048576, // 1MB == 32seconds of speech
MaxBufferSize = 1048576, // 1MB == 32seconds of speech
});
RouteTable.Routes.MapServiceRoute<SuggestionResource>("suggestions", null);
RouteTable.Routes.MapServiceRoute<TagResource>("tags", null);
RouteTable.Routes.MapServiceRoute<TraceResource>("trace", null);
RouteTable.Routes.MapServiceRoute<UserResource>("users", config);
}
public static void CreateHosts(List<HttpServiceHost> hosts, HttpConfiguration config, Uri baseurl)
{
hosts.Add(new HttpServiceHost(typeof(HypermediaAPI.RootController), config, baseurl));
Login.LoginController.CreateHosts(hosts,config,baseurl + "Login/");
Partner.PartnerController.CreateHosts(hosts, config, baseurl + "Partner/");
}
// This will get called by a parameter binding, which will cache the results.
public ModelBinderProvider GetModelBinderProvider(HttpConfiguration configuration)
{
if (BinderType != null)
{
object value = configuration.DependencyResolver.GetService(BinderType)
?? Activator.CreateInstance(BinderType);
if (value != null)
{
VerifyBinderType(value.GetType());
ModelBinderProvider result = (ModelBinderProvider)value;
return result;
}
}
// Create default over config
IEnumerable<ModelBinderProvider> providers = configuration.Services.GetModelBinderProviders();
if (providers.Count() == 1)
{
return providers.First();
}
return new CompositeModelBinderProvider(providers);
}
public void IsRequiredMember_ReturnsFalse_ForNullableProperties(string propertyName)
{
HttpConfiguration config = new HttpConfiguration();
IRequiredMemberSelector selector = new ModelValidationRequiredMemberSelector(config.Services.GetModelMetadataProvider(), config.Services.GetModelValidatorProviders());
Assert.False(selector.IsRequiredMember(typeof(NullableProperties).GetProperty(propertyName)));
}
public void VerifyCustomDocumentationProviderMessage()
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
ItemFormatter customFormatter = new ItemFormatter();
config.Formatters.Add(customFormatter);
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(DocumentationController));
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
AttributeDocumentationProvider documentationProvider = new AttributeDocumentationProvider();
config.Services.Replace(typeof(IDocumentationProvider), documentationProvider);
IApiExplorer explorer = config.Services.GetApiExplorer();
foreach (ApiDescription description in explorer.ApiDescriptions)
{
Assert.Equal(
String.Format("{0} action", description.ActionDescriptor.ActionName),
description.Documentation);
foreach (ApiParameterDescription param in description.ParameterDescriptions)
{
Assert.Equal(
String.Format("{0} parameter", param.Name),
param.Documentation);
}
}
}
public void GetCorsPolicyProvider_Preflight_DisposesControllerAfterActionSelection()
{
// Arrange
AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
request.Headers.Add("Origin", "http://localhost");
request.Headers.Add(CorsConstants.AccessControlRequestMethod, "POST");
HttpConfiguration config = new HttpConfiguration();
HttpControllerContext controllerContext = null;
var actionSelector = new Mock<IHttpActionSelector>();
actionSelector.Setup(s => s.SelectAction(It.IsAny<HttpControllerContext>()))
.Callback<HttpControllerContext>(context =>
{
Assert.False(((SampleController)context.Controller).Disposed);
controllerContext = context;
});
config.Services.Replace(typeof(IHttpActionSelector), actionSelector.Object);
request.SetConfiguration(config);
IHttpRoute route = config.Routes.MapHttpRoute("default", "{controller}/{id}", new { id = RouteParameter.Optional });
request.SetRouteData(route.GetRouteData("/", request));
ICorsPolicyProvider provider = providerFactory.GetCorsPolicyProvider(request);
// Assert
Assert.True(((SampleController)controllerContext.Controller).Disposed);
}
public void IsRequiredMember_RecognizesRequiredMembers(string propertyName, bool isRequired)
{
HttpConfiguration config = new HttpConfiguration();
IRequiredMemberSelector selector = new ModelValidationRequiredMemberSelector(config.Services.GetModelMetadataProvider(), config.Services.GetModelValidatorProviders());
Assert.Equal(isRequired, selector.IsRequiredMember(typeof(PurchaseOrder).GetProperty(propertyName)));
}
public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
{
return ModelBindingHelper.GetPossibleBinderInstance(
closedModelType: modelType,
openModelType: typeof(KeyValuePair<,>),
openBinderType: typeof(KeyValuePairModelBinder<,>));
}
public void Apply_AddsFeedSelfLink_ThatThrowsForMissingRoute()
{
// Arrange
Func<FeedContext, Uri> feedSelfLink = null;
var mockEntityType = new Mock<EntityTypeConfiguration>();
var mockEntitySet = new Mock<EntitySetConfiguration>();
mockEntitySet.Setup(entitySet => entitySet.EntityType).Returns(mockEntityType.Object);
mockEntitySet.Setup(entitySet => entitySet.HasFeedSelfLink(It.IsAny<Func<FeedContext, Uri>>()))
.Returns(mockEntitySet.Object)
.Callback<Func<FeedContext, Uri>>(selfLink => { feedSelfLink = selfLink; });
var mockModelBuilder = new Mock<ODataModelBuilder>();
HttpConfiguration configuration = new HttpConfiguration();
HttpRequestMessage request = new HttpRequestMessage();
request.Properties["MS_HttpConfiguration"] = configuration;
FeedContext context = new FeedContext(new Mock<IEdmEntitySet>().Object, new UrlHelper(request), new Product[0]);
// Act
new SelfLinksGenerationConvention().Apply(mockEntitySet.Object, mockModelBuilder.Object);
// Assert
Assert.NotNull(feedSelfLink);
Assert.ThrowsArgument(() => feedSelfLink(context), "name",
"A route named 'OData.Default' could not be found in the route collection");
}
public static void Run()
{
var config = new HttpConfiguration();
config.RequestHandlers += (coll, ep, desc) =>
{
if (
desc.Attributes.Any(a => a.GetType() == typeof(JsonExtractAttribute))
)
{
coll.Add(new JsonExtractHandler(desc));
}
};
using (var sh = new HttpServiceHost(typeof(TheService), config, "http://localhost:8080"))
{
sh.Open();
Console.WriteLine("host is opened");
var client = new HttpClient();
dynamic data = new JsonObject();
data.x = "a string";
data.y = "13";
data.z = "3.14";
var resp = client.PostAsync("http://localhost:8080/v2", new ObjectContent<JsonValue>(data, "application/json")).Result;
Console.WriteLine(resp.StatusCode);
}
}
[InlineData("GET", "http://localhost/Customers(42)/NS.SpecialCustomer/IsSpecialUpgraded()", "IsSpecialUpgraded_42")] // function bound to 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(MetadataController), typeof(OrdersController) };
TestAssemblyResolver resolver = new TestAssemblyResolver(new MockAssembly(controllers));
HttpConfiguration config = new HttpConfiguration();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
config.Services.Replace(typeof(IAssembliesResolver), resolver);
config.Routes
.MapODataRoute("odata", "", model.Model)
.MapODataRouteAttributes(config);
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);
}
/// <summary>
/// This was a test to see how painful it is to create a large number of service hosts.
/// </summary>
/// <param name="args"></param>
public static void Main2(string[] args)
{
var serviceLocator = new ServiceLocator(CreateDIContainer());
for (int i = 0; i < 1000; i++) {
var baseurl = new Uri("http://localhost:1000/service" + i);
var config = new HttpConfiguration();
config.CreateInstance = (type, context, request) => serviceLocator.GetInstance(type);
config.RequestHandlers = (handlers, se, od ) => handlers.Add(new ServerStateOperationHandler(null));
config.ResponseHandlers = (handlers, se, od) => {
handlers.Add(new LoggingOperationHandler(new Logger()));
handlers.Add(new CompressionHandler());
};
var host = new HttpServiceHost(typeof(FooService), config, baseurl);
host.Open();
Console.WriteLine("Opening host open " + baseurl);
}
Console.WriteLine("Host open. Hit enter to exit...");
// Console.WriteLine("Use a web browser and go to " + baseurl + " or do it right and get fiddler!");
Console.Read();
// host.Close();
}
static void Main(string[] args)
{
var serviceLocator = new ServiceLocator(CreateDIContainer());
var baseurl = new Uri("http://localhost:1000/");
var serverState = new ServerState();
serverState["Hello"] = "World";
var config = new HttpConfiguration();
config.CreateInstance = (type, context, request) => serviceLocator.GetInstance(type);
config.RequestHandlers = (handlers, se, od) => handlers.Add(new ServerStateOperationHandler(serverState));
config.ResponseHandlers = (handlers, se, od) => {
handlers.Add(new LoggingOperationHandler(new Logger()));
handlers.Add(new CompressionHandler());
};
config.Formatters.Insert(0, new JsonMediaTypeFormatter());
HttpServiceHost host = new HttpServiceHost(typeof(FooService), config, baseurl);
host.Open();
Console.WriteLine("Host open. Hit enter to exit...");
Console.WriteLine("Use a web browser and go to " + baseurl + " or do it right and get fiddler!");
Console.Read();
host.Close();
}
public void GenerateActionLink_GeneratesLinkWithoutCast_IfEntitySetTypeMatchesActionEntityType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var cars = builder.EntitySet<Car>("cars");
var paintAction = cars.EntityType.Action("Paint");
IEdmModel model = builder.GetEdmModel();
var carsEdmSet = model.EntityContainers().Single().FindEntitySet("cars");
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.Routes.MapODataRoute(routeName, null, model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.SetConfiguration(configuration);
request.SetODataRouteName(routeName);
// Act
Uri link = ActionLinkGenerationConvention.GenerateActionLink(
new EntityInstanceContext()
{
EdmModel = model,
EntitySet = carsEdmSet,
EntityType = carsEdmSet.ElementType,
Url = request.GetUrlHelper(),
EntityInstance = new Car { Model = 2009, Name = "Accord" }
},
paintAction);
Assert.Equal("http://localhost/cars(Model=2009,Name='Accord')/Paint", link.AbsoluteUri);
}
public HttpControllerContext(HttpConfiguration configuration, IHttpRouteData routeData,
HttpRequestMessage request)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
if (routeData == null)
{
throw Error.ArgumentNull("routeData");
}
if (request == null)
{
throw Error.ArgumentNull("request");
}
_requestContext = new HttpRequestContext
{
Configuration = configuration,
RouteData = routeData
};
_request = request;
}
public void SendAsync_Preflight_ReturnsAllowMethodsAndAllowHeaders(string requestedMethod, string expectedOrigin, string requestedHeaders)
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute("default", "{controller}");
HttpServer server = new HttpServer(config);
CorsMessageHandler corsHandler = new CorsMessageHandler(config);
corsHandler.InnerHandler = server;
HttpMessageInvoker invoker = new HttpMessageInvoker(corsHandler);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
request.SetConfiguration(config);
request.Headers.Add(CorsConstants.Origin, "http://localhost");
request.Headers.Add(CorsConstants.AccessControlRequestMethod, requestedMethod);
request.Headers.Add(CorsConstants.AccessControlRequestHeaders, requestedHeaders);
HttpResponseMessage response = invoker.SendAsync(request, CancellationToken.None).Result;
string origin = response.Headers.GetValues(CorsConstants.AccessControlAllowOrigin).FirstOrDefault();
string allowMethod = response.Headers.GetValues(CorsConstants.AccessControlAllowMethods).FirstOrDefault();
string[] allowHeaders = response.Headers.GetValues(CorsConstants.AccessControlAllowHeaders).FirstOrDefault().Split(',');
string[] requestedHeaderArray = requestedHeaders.Split(',');
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(expectedOrigin, origin);
Assert.Equal(requestedMethod, allowMethod);
foreach (string requestedHeader in requestedHeaderArray)
{
Assert.Contains(requestedHeader, allowHeaders);
}
}
public TestBase()
{
Request = new HttpRequestMessage();
HttpConfiguration = new HttpConfiguration();
ContainerBuilder = new ContainerBuilder();
ContainerBuilder.RegisterApiControllers(typeof(AddressesController).Assembly);
}
public HelpController(HttpConfiguration config)
{
Configuration = config;
}
private static HelpPageApiModel GenerateApiModel(ApiDescription apiDescription, HttpConfiguration config)
{
HelpPageApiModel apiModel = new HelpPageApiModel()
{
ApiDescription = apiDescription,
};
ModelDescriptionGenerator modelGenerator = config.GetModelDescriptionGenerator();
HelpPageSampleGenerator sampleGenerator = config.GetHelpPageSampleGenerator();
GenerateUriParameters(apiModel, modelGenerator);
GenerateRequestModelDescription(apiModel, modelGenerator, sampleGenerator);
GenerateResourceDescription(apiModel, modelGenerator);
GenerateSamples(apiModel, sampleGenerator);
return apiModel;
}
/// <summary>
/// Gets the model description generator.
/// </summary>
/// <param name="config">The configuration.</param>
/// <returns>The <see cref="ModelDescriptionGenerator"/></returns>
public static ModelDescriptionGenerator GetModelDescriptionGenerator(this HttpConfiguration config)
{
return (ModelDescriptionGenerator)config.Properties.GetOrAdd(
typeof(ModelDescriptionGenerator),
k => InitializeModelDescriptionGenerator(config));
}
/// <summary>
/// Gets the help page sample generator.
/// </summary>
/// <param name="config">The <see cref="HttpConfiguration"/>.</param>
/// <returns>The help page sample generator.</returns>
public static HelpPageSampleGenerator GetHelpPageSampleGenerator(this HttpConfiguration config)
{
return (HelpPageSampleGenerator)config.Properties.GetOrAdd(
typeof(HelpPageSampleGenerator),
k => new HelpPageSampleGenerator());
}
/// <summary>
/// Specifies the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> returned as part of the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
/// The help page will use this information to produce more accurate response samples.
/// </summary>
/// <param name="config">The <see cref="HttpConfiguration"/>.</param>
/// <param name="type">The type.</param>
/// <param name="controllerName">Name of the controller.</param>
/// <param name="actionName">Name of the action.</param>
/// <param name="parameterNames">The parameter names.</param>
public static void SetActualResponseType(this HttpConfiguration config, Type type, string controllerName, string actionName, params string[] parameterNames)
{
config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Response, controllerName, actionName, parameterNames), type);
}
/// <summary>
/// Specifies the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> passed to the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
/// The help page will use this information to produce more accurate request samples.
/// </summary>
/// <param name="config">The <see cref="HttpConfiguration"/>.</param>
/// <param name="type">The type.</param>
/// <param name="controllerName">Name of the controller.</param>
/// <param name="actionName">Name of the action.</param>
public static void SetActualRequestType(this HttpConfiguration config, Type type, string controllerName, string actionName)
{
config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Request, controllerName, actionName, new[] { "*" }), type);
}
/// <summary>
/// Sets the sample directly for all actions with the specified type and media type.
/// </summary>
/// <param name="config">The <see cref="HttpConfiguration"/>.</param>
/// <param name="sample">The sample.</param>
/// <param name="mediaType">The media type.</param>
/// <param name="type">The parameter type or return type of an action.</param>
public static void SetSampleForType(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, Type type)
{
config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, type), sample);
}
/// <summary>
/// Sets the sample request directly for the specified media type and action.
/// </summary>
/// <param name="config">The <see cref="HttpConfiguration"/>.</param>
/// <param name="sample">The sample request.</param>
/// <param name="mediaType">The media type.</param>
/// <param name="controllerName">Name of the controller.</param>
/// <param name="actionName">Name of the action.</param>
public static void SetSampleRequest(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName)
{
config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, SampleDirection.Request, controllerName, actionName, new[] { "*" }), sample);
}
/// <summary>
/// Sets the sample response directly for the specified media type of the action with specific parameters.
/// </summary>
/// <param name="config">The <see cref="HttpConfiguration"/>.</param>
/// <param name="sample">The sample response.</param>
/// <param name="mediaType">The media type.</param>
/// <param name="controllerName">Name of the controller.</param>
/// <param name="actionName">Name of the action.</param>
/// <param name="parameterNames">The parameter names.</param>
public static void SetSampleResponse(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName, params string[] parameterNames)
{
config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, SampleDirection.Response, controllerName, actionName, parameterNames), sample);
}
/// <summary>
/// Sets the documentation provider for help page.
/// </summary>
/// <param name="config">The <see cref="HttpConfiguration"/>.</param>
/// <param name="documentationProvider">The documentation provider.</param>
public static void SetDocumentationProvider(this HttpConfiguration config, IDocumentationProvider documentationProvider)
{
config.Services.Replace(typeof(IDocumentationProvider), documentationProvider);
}
/// <summary>
/// Sets the objects that will be used by the formatters to produce sample requests/responses.
/// </summary>
/// <param name="config">The <see cref="HttpConfiguration"/>.</param>
/// <param name="sampleObjects">The sample objects.</param>
public static void SetSampleObjects(this HttpConfiguration config, IDictionary<Type, object> sampleObjects)
{
config.GetHelpPageSampleGenerator().SampleObjects = sampleObjects;
}
public void Configuration(IAppBuilder app)
{
var builder = new ContainerBuilder();
builder.RegisterType <MongoContext>().AsImplementedInterfaces <MongoContext, ConcreteReflectionActivatorData>().SingleInstance();
builder.RegisterType <AuthRepository>().SingleInstance();
builder.RegisterType <CalculatorRepository>().SingleInstance();
//builder.RegisterType<CalculatorRepository>()
// .WithParameters(new Parameter[]
// {
// new ResolvedParameter((info, context) => info.Name == "mongoContext",
// (info, context) => context.Resolve<IMongoContext>()),
// new ResolvedParameter((info, context) => info.Name == "userManager",
// (info, context) => context.Resolve<ApplicationUserManager>())
// }).SingleInstance();
builder.RegisterType <ApplicationIdentityContext>()
.SingleInstance();
builder.RegisterType <UserStore <User> >()
.AsImplementedInterfaces <IUserStore <User>, ConcreteReflectionActivatorData>()
.SingleInstance();
builder.RegisterType <RoleStore <Role> >()
.AsImplementedInterfaces <IRoleStore <Role>, ConcreteReflectionActivatorData>()
.SingleInstance();
builder.RegisterType <ApplicationUserManager>()
.SingleInstance();
builder.RegisterType <ApplicationRoleManager>()
.SingleInstance();
builder.RegisterType <SimpleAuthorizationServerProvider>()
.AsImplementedInterfaces <IOAuthAuthorizationServerProvider, ConcreteReflectionActivatorData>().SingleInstance();
builder.RegisterType <SimpleRefreshTokenProvider>()
.AsImplementedInterfaces <IAuthenticationTokenProvider, ConcreteReflectionActivatorData>().SingleInstance();
//builder.RegisterType<SimpleAuthorizationServerProvider>()
// .AsImplementedInterfaces<IOAuthAuthorizationServerProvider, ConcreteReflectionActivatorData>()
// .WithParameters(new Parameter[]
// {
// new NamedParameter("publicClientId", "self"),
// new ResolvedParameter((info, context) => info.Name == "userManager",
// (info, context) => context.Resolve<ApplicationUserManager>())
// });
builder.RegisterApiControllers(typeof(Startup).Assembly);
var container = builder.Build();
app.UseAutofacMiddleware(container);
var webApiDependencyResolver = new AutofacWebApiDependencyResolver(container);
var configuration = new HttpConfiguration
{
DependencyResolver = webApiDependencyResolver
};
ConfigureOAuth(app, container);
WebApiConfig.Register(configuration);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseWebApi(configuration);
app.UseAutofacWebApi(configuration);
InitializeData(container);
}
public RestierQueryBuilderTests()
{
var configuration = new HttpConfiguration();
configuration.MapRestierRoute<StoreApi>("store", "store").Wait();
client = new HttpClient(new HttpServer(configuration));
}
public static void Initialize(HttpConfiguration config)
{
Initialize(config, RegisterServices(new ContainerBuilder()));
}
public static void Initialize(HttpConfiguration config, IContainer container)
{
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
internal HttpControllerTypeCache(HttpConfiguration configuration)
{
this.configuration = configuration;
cache = new Lazy <Dictionary <string, ILookup <string, Type> > >(InitializeCache);
}
public CurrencyLayerScrudViewRouteTests()
{
this.Host = ConfigurationManager.AppSettings["HostPrefix"];
this.ApiVersionNumber = ConfigurationManager.AppSettings["ApiVersionNumber"];
this.Config = GetConfig();
}
private static void RegisterFilters(HttpConfiguration config)
{
// None
}
public static void Register(HttpConfiguration configuration)
{
configuration.MapHttpAttributeRoutes();
configuration.Routes.MapHttpRoute("API Default", "api/{controller}/{id}",
new { id = RouteParameter.Optional });
}
// Get a controller descriptor that's sufficiently initialized to use with parameter binding
private HttpControllerDescriptor GetControllerDescriptor(HttpConfiguration config)
{
return(new HttpControllerDescriptor(config));
}
public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
{
return(new AbpModelBinder());
}
public EmailQueueRouteTests()
{
this.Host = ConfigurationManager.AppSettings["HostPrefix"];
this.ApiVersionNumber = ConfigurationManager.AppSettings["ApiVersionNumber"];
this.Config = GetConfig();
}
public BatchServer(HttpConfiguration configuration)
: base(configuration)
{
_config = configuration;
}
public async Task WebHost_Batching_WithSpecialCharactersInUrl()
{
// Arrange
var handler = new SuccessMessageHandler();
var routeCollection = new HostedHttpRouteCollection(new RouteCollection(), "/");
routeCollection.Add("default", routeCollection.CreateRoute(
"values/ space",
defaults: null,
constraints: null,
dataTokens: null,
handler: handler));
var configuration = new HttpConfiguration(routeCollection);
var server = new HttpServer(configuration);
var batchHandler = new DefaultHttpBatchHandler(server);
var request = new HttpRequestMessage
{
Content = new MultipartContent("mixed")
{
new HttpMessageContent(new HttpRequestMessage(HttpMethod.Post, "http://contoso.com/values/ space"))
}
};
// Arrange
var response = await batchHandler.ProcessBatchAsync(request, CancellationToken.None);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.True(handler.IsCalled);
}
