public async Task UseRouter_Action_CallsRoute() { // Arrange var services = CreateServices(); var app = new ApplicationBuilder(services); var router = new Mock <IRouter>(MockBehavior.Strict); router .Setup(r => r.RouteAsync(It.IsAny <RouteContext>())) .Returns(Task.CompletedTask) .Verifiable(); app.UseRouter(b => { b.Routes.Add(router.Object); }); var appFunc = app.Build(); // Act await appFunc(new DefaultHttpContext()); // Assert router.Verify(); }
public async Task UseRouting_ServicesRegistered_Match_DoesNotSetsFeature() { // Arrange var endpoint = new RouteEndpoint( TestConstants.EmptyRequestDelegate, RoutePatternFactory.Parse("{*p}"), 0, EndpointMetadataCollection.Empty, "Test"); var services = CreateServices(); var app = new ApplicationBuilder(services); app.UseRouting(builder => { builder.DataSources.Add(new DefaultEndpointDataSource(endpoint)); }); var appFunc = app.Build(); var httpContext = new DefaultHttpContext(); // Act await appFunc(httpContext); // Assert var feature = httpContext.Features.Get <IEndpointFeature>(); Assert.NotNull(feature); Assert.Same(endpoint, feature.Endpoint); }
public void UseEndpoints_CallWithBuilder_SetsEndpointDataSource() { // Arrange var matcherEndpointDataSources = new List <EndpointDataSource>(); var matcherFactoryMock = new Mock <MatcherFactory>(); matcherFactoryMock .Setup(m => m.CreateMatcher(It.IsAny <EndpointDataSource>())) .Callback((EndpointDataSource arg) => { matcherEndpointDataSources.Add(arg); }) .Returns(new TestMatcher(false)); var services = CreateServices(matcherFactoryMock.Object); var app = new ApplicationBuilder(services); // Act app.UseRouting(); app.UseEndpoints(builder => { builder.Map("/1", d => null).WithDisplayName("Test endpoint 1"); builder.Map("/2", d => null).WithDisplayName("Test endpoint 2"); }); app.UseRouting(); app.UseEndpoints(builder => { builder.Map("/3", d => null).WithDisplayName("Test endpoint 3"); builder.Map("/4", d => null).WithDisplayName("Test endpoint 4"); }); // This triggers the middleware to be created and the matcher factory to be called // with the datasource we want to test var requestDelegate = app.Build(); requestDelegate(new DefaultHttpContext()); // Assert Assert.Equal(2, matcherEndpointDataSources.Count); // each UseRouter has its own data source collection Assert.Collection(matcherEndpointDataSources[0].Endpoints, e => Assert.Equal("Test endpoint 1", e.DisplayName), e => Assert.Equal("Test endpoint 2", e.DisplayName)); Assert.Collection(matcherEndpointDataSources[1].Endpoints, e => Assert.Equal("Test endpoint 3", e.DisplayName), e => Assert.Equal("Test endpoint 4", e.DisplayName)); var compositeEndpointBuilder = services.GetRequiredService <EndpointDataSource>(); // Global collection has all endpoints Assert.Collection(compositeEndpointBuilder.Endpoints, e => Assert.Equal("Test endpoint 1", e.DisplayName), e => Assert.Equal("Test endpoint 2", e.DisplayName), e => Assert.Equal("Test endpoint 3", e.DisplayName), e => Assert.Equal("Test endpoint 4", e.DisplayName)); }
public async Task UseEndpointExecutor_RunsEndpoint() { // Arrange var services = CreateServices(); var endpointRan = false; var app = new ApplicationBuilder(services); app.Use(next => context => { context.SetEndpoint(new Endpoint(c => { endpointRan = true; return(Task.CompletedTask); }, new EndpointMetadataCollection(), "Test")); return(next(context)); }); app.UseEndpointExecutor(); // No services required, no UseRouting required var appFunc = app.Build(); var httpContext = new DefaultHttpContext(); // Act await appFunc(httpContext); // Assert Assert.True(endpointRan); }
public static IApplicationBuilder UseBuilder(this AddMiddleware app, IServiceProvider serviceProvider) { if (app == null) { throw new ArgumentNullException(nameof(app)); } // Do not set ApplicationBuilder.ApplicationServices to null. May fail later due to missing services but // at least that results in a more useful Exception than a NRE. if (serviceProvider == null) { serviceProvider = new EmptyProvider(); } // Adapt WebSockets by default. app(OwinWebSocketAcceptAdapter.AdaptWebSockets); var builder = new ApplicationBuilder(serviceProvider: serviceProvider); var middleware = CreateMiddlewareFactory(exit => { builder.Use(ignored => exit); return(builder.Build()); }, builder.ApplicationServices); app(middleware); return(builder); }
public void UseEndpoints_WithGlobalEndpointRouteBuilderHasRoutes() { // Arrange var services = CreateServices(); var app = new ApplicationBuilder(services); var mockRouteBuilder = new Mock <IEndpointRouteBuilder>(); mockRouteBuilder.Setup(m => m.DataSources).Returns(new List <EndpointDataSource>()); var routeBuilder = mockRouteBuilder.Object; app.Properties.Add("__GlobalEndpointRouteBuilder", routeBuilder); app.UseRouting(); app.UseEndpoints(endpoints => { endpoints.Map("/1", d => Task.CompletedTask).WithDisplayName("Test endpoint 1"); }); var requestDelegate = app.Build(); var endpointDataSource = Assert.Single(mockRouteBuilder.Object.DataSources); Assert.Collection(endpointDataSource.Endpoints, e => Assert.Equal("Test endpoint 1", e.DisplayName)); var routeOptions = app.ApplicationServices.GetRequiredService <IOptions <RouteOptions> >(); Assert.Equal(mockRouteBuilder.Object.DataSources, routeOptions.Value.EndpointDataSources); }
public async Task UseRouting_ServicesRegistered_NoMatch_DoesNotSetFeature() { // Arrange var services = CreateServices(); var app = new ApplicationBuilder(services); app.UseRouting(builder => { }); var appFunc = app.Build(); var httpContext = new DefaultHttpContext(); // Act await appFunc(httpContext); // Assert Assert.Null(httpContext.Features.Get <IEndpointFeature>()); }
public async Task UseEndpoint_ServicesRegisteredAndEndpointRoutingRegistered_SetsFeature() { // Arrange var services = CreateServices(); var app = new ApplicationBuilder(services); app.UseEndpointRouting(); app.UseEndpoint(); var appFunc = app.Build(); var httpContext = new DefaultHttpContext(); // Act await appFunc(httpContext); // Assert Assert.NotNull(httpContext.Features.Get <IEndpointFeature>()); }
/// <summary> /// Creates a new isolated application builder which gets its own <see cref="ServiceCollection"/>, which only /// has the default services registered. It will not share the <see cref="ServiceCollection"/> from the /// originating app. /// </summary> /// <param name="app">The application builder to create the isolated app from.</param> /// <param name="configuration">The branch of the isolated app.</param> /// <param name="registration">A method to configure the newly created service collection.</param> /// <returns>The new pipeline with the isolated application integrated.</returns> public static IApplicationBuilder Isolate( this IApplicationBuilder app, Action <IApplicationBuilder> configuration, Func <IServiceCollection, IServiceProvider> registration) { var services = CreateDefaultServiceCollection(app.ApplicationServices); var provider = registration(services); var builder = new ApplicationBuilder(null); builder.ApplicationServices = provider; builder.Use(async(context, next) => { var factory = provider.GetRequiredService <IServiceScopeFactory>(); // Store the original request services in the current ASP.NET context. context.Items[typeof(IServiceProvider)] = context.RequestServices; try { using (var scope = factory.CreateScope()) { context.RequestServices = scope.ServiceProvider; await next(); } } finally { context.RequestServices = null; } }); configuration(builder); return(app.Use(next => { // Run the rest of the pipeline in the original context, // with the services defined by the parent application builder. builder.Run(async context => { var factory = app.ApplicationServices.GetRequiredService <IServiceScopeFactory>(); try { using (var scope = factory.CreateScope()) { context.RequestServices = scope.ServiceProvider; await next(context); } } finally { context.RequestServices = null; } }); var branch = builder.Build(); return context => branch(context); })); }