public void BuildReturnsCallableDelegate()
{
var builder = new ApplicationBuilder(null);
var app = builder.Build();
var mockHttpContext = new Moq.Mock<HttpContext>();
var mockHttpResponse = new Moq.Mock<HttpResponse>();
mockHttpContext.SetupGet(x => x.Response).Returns(mockHttpResponse.Object);
mockHttpResponse.SetupProperty(x => x.StatusCode);
app.Invoke(mockHttpContext.Object);
Assert.Equal(mockHttpContext.Object.Response.StatusCode, 404);
}
public async Task UseAuthorization_HasRequiredSevices_RegistersMiddleware()
{
// Arrange
var authenticationService = new TestAuthenticationService();
var services = CreateServices(authenticationService);
var app = new ApplicationBuilder(services);
app.UseAuthorization();
var appFunc = app.Build();
var endpoint = new Endpoint(
null,
new EndpointMetadataCollection(new AuthorizeAttribute()),
"Test endpoint");
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = services;
httpContext.SetEndpoint(endpoint);
// Act
await appFunc(httpContext);
// Assert
Assert.True(authenticationService.ChallengeCalled);
}
private static async Task VerifyRouteDebug(string requestPath, bool lastCalledExpected, Action <ApplicationBuilder> config)
{
// Arrange
IServiceCollection services = new ServiceCollection();
services.TryAddEnumerable(
ServiceDescriptor.Singleton <EndpointDataSource>(new DefaultEndpointDataSource(Array.Empty <Endpoint>())));
IServiceProvider sp = services.BuildServiceProvider();
ApplicationBuilder builder = new ApplicationBuilder(serviceProvider: sp);
DefaultHttpContext context = new DefaultHttpContext();
context.RequestServices = sp;
context.Request.Path = new PathString(requestPath);
bool lastCalled = false;
// Act
config(builder); // first - middleware
builder.Run(context => // second - middleware
{
lastCalled = true;
return(Task.CompletedTask);
});
await builder.Build().Invoke(context);
// Assert
Assert.Equal(lastCalledExpected, lastCalled);
}
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();
app.UseEndpoints(endpoints =>
{
endpoints.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, httpContext.GetEndpoint());
}
public void UseMiddlewareWithIvokeWithOutAndRefThrows()
{
var mockServiceProvider = new DummyServiceProvider();
var builder = new ApplicationBuilder(mockServiceProvider);
builder.UseMiddleware(typeof(MiddlewareInjectWithOutAndRefParams));
var exception = Assert.Throws<NotSupportedException>(() => builder.Build());
}
public Task ActivatingAsync()
{
// Build the middleware pipeline for the current tenant
IApplicationBuilder appBuilder = new ApplicationBuilder(_serviceProvider);
var orderedMiddlewares = _middlewareProviders
.SelectMany(p => p.GetMiddlewares())
.OrderBy(obj => obj.Priority)
.ToArray();
foreach (var middleware in orderedMiddlewares)
{
middleware.Configure(appBuilder);
}
// Orchard is always the last middleware
appBuilder.UseMiddleware<OrchardMiddleware>();
var pipeline = appBuilder.Build();
_routePublisher.Publish(
_routeProviders.SelectMany(provider => provider.GetRoutes()),
pipeline
);
return Task.CompletedTask;
}
public void ModuleServiceContext_Startup_Should_Ok()
{
var services = new ServiceCollection();
//replace hostingEnvironment:
//var hostingEnvironment = new HostingEnvironment();
//hostingEnvironment.ApplicationName = GetType().Assembly.GetName().Name;
//hostingEnvironment.ContentRootPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Modules");
//services.AddSingleton(typeof(IHostingEnvironment), hostingEnvironment);
services.AddMyModules();
var provider = services.BuildServiceProvider();
var builder = new ApplicationBuilder(provider);
builder.UseMyModules();
builder.Build();
var context = provider.GetService <IModuleServiceContext>();
context.ShouldNotNull();
var modules = builder.ApplicationServices.GetServices <IModuleStartup>().ToList();
modules.Log();
modules.Count.ShouldEqual(2);
}
// Build the middleware pipeline for the current tenant
private IShellPipeline BuildTenantPipeline()
{
var appBuilder = new ApplicationBuilder(ShellScope.Context.ServiceProvider, _features);
// Create a nested pipeline to configure the tenant middleware pipeline
var startupFilters = appBuilder.ApplicationServices.GetService <IEnumerable <IStartupFilter> >();
var shellPipeline = new ShellRequestPipeline();
Action <IApplicationBuilder> configure = builder =>
{
ConfigureTenantPipeline(builder);
};
foreach (var filter in startupFilters.Reverse())
{
configure = filter.Configure(configure);
}
configure(appBuilder);
shellPipeline.Next = appBuilder.Build();
return(shellPipeline);
}
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();
}
// Build the middleware pipeline for the current tenant
public RequestDelegate BuildTenantPipeline(IServiceProvider serviceProvider)
{
var startups = serviceProvider.GetServices <IStartup>();
// IStartup instances are ordered by module dependency with an Order of 0 by default.
// OrderBy performs a stable sort so order is preserved among equal Order values.
startups = startups.OrderBy(s => s.Order);
var tenantRouteBuilder = serviceProvider.GetService <IModularTenantRouteBuilder>();
var appBuilder = new ApplicationBuilder(serviceProvider);
var routeBuilder = tenantRouteBuilder.Build();
foreach (var startup in startups)
{
startup.Configure(appBuilder, routeBuilder, serviceProvider);
}
tenantRouteBuilder.Configure(routeBuilder);
var router = routeBuilder.Build();
appBuilder.UseRouter(router);
var pipeline = appBuilder.Build();
return(pipeline);
}
// Build the middleware pipeline for the current tenant
public RequestDelegate BuildTenantPipeline(ShellSettings shellSettings, IServiceProvider serviceProvider)
{
var startups = serviceProvider.GetServices <IStartup>();
// IStartup instances are ordered by module dependency with an Order of 0 by default.
// OrderBy performs a stable sort so order is preserved among equal Order values.
startups = startups.OrderBy(s => s.Order);
var tenantRouteBuilder = serviceProvider.GetService <IModularTenantRouteBuilder>();
var appBuilder = new ApplicationBuilder(serviceProvider);
var routeBuilder = tenantRouteBuilder.Build();
// In the case of several tenants, they will all be checked by ShellSettings. To optimize
// the TenantRoute resolution we can create a single Router type that would index the
// TenantRoute object by their ShellSetting. This way there would just be one lookup.
// And the ShellSettings test in TenantRoute would also be useless.
foreach (var startup in startups)
{
startup.Configure(appBuilder, routeBuilder, serviceProvider);
}
tenantRouteBuilder.Configure(routeBuilder);
var router = routeBuilder.Build();
appBuilder.UseRouter(router);
var pipeline = appBuilder.Build();
return(pipeline);
}
private IShellPipeline BuildTenantPipeline()
{
V_0 = new ApplicationBuilder(ShellScope.get_Context().get_ServiceProvider(), this._features);
stackVariable7 = ServiceProviderServiceExtensions.GetService <IEnumerable <IStartupFilter> >(V_0.get_ApplicationServices());
V_1 = new ShellRequestPipeline();
V_2 = new Action <IApplicationBuilder>(this.u003cBuildTenantPipelineu003eb__6_0);
V_3 = stackVariable7.Reverse <IStartupFilter>().GetEnumerator();
try
{
while (V_3.MoveNext())
{
V_2 = V_3.get_Current().Configure(V_2);
}
}
finally
{
if (V_3 != null)
{
V_3.Dispose();
}
}
V_2.Invoke(V_0);
V_1.set_Next(V_0.Build());
return(V_1);
}
// Build the middleware pipeline for the current tenant
public RequestDelegate BuildTenantPipeline(ShellSettings shellSettings, HttpContext httpContext)
{
var serviceProvider = httpContext.RequestServices;
var startUps = serviceProvider.GetServices <IStartup>();
var inlineConstraintResolver = serviceProvider.GetService <IInlineConstraintResolver>();
var appBuilder = new ApplicationBuilder(serviceProvider);
var routePrefix = string.Empty;
if (!string.IsNullOrWhiteSpace(shellSettings.RequestedUrlPrefix))
{
routePrefix = shellSettings.RequestedUrlPrefix + "/";
}
// Create a default routebuilder using our PlatoRouter implementation
var routeBuilder = new RouteBuilder(appBuilder, new RouteHandler(_next))
{
DefaultHandler = serviceProvider.GetRequiredService <IPlatoRouter>()
};
// Build prefixed route builder
var prefixedRouteBuilder = new PrefixedRouteBuilder(
routePrefix,
routeBuilder,
inlineConstraintResolver);
// Configure modules
foreach (var startup in startUps)
{
startup.Configure(appBuilder, prefixedRouteBuilder, serviceProvider);
}
// Add the default template route to each shell
prefixedRouteBuilder.Routes.Add(new Route(
prefixedRouteBuilder.DefaultHandler,
"PlatoDefault",
"{area:exists}/{controller}/{action}/{id?}",
null,
null,
null,
inlineConstraintResolver)
);
// Build router
var router = prefixedRouteBuilder.Build();
// Use router
appBuilder.UseRouter(router);
// Configure captured http context
ConfigureCapturedHttpContext(httpContext, serviceProvider);
// Configure captured router
ConfigureCapturedRouter(httpContext, serviceProvider, router);
// Build & return new pipeline
var pipeline = appBuilder.Build();
return(pipeline);
}
static void Main(string[] args)
{
//AnotherPlayground.Play();
//return;
var appBuilder = new ApplicationBuilder();
appBuilder.UseAgpml();
appBuilder.UseDss();
appBuilder.Configure <AgpxOptions>((options) =>
{
//options.Styles.Add(parseTestStyle());
});
appBuilder.UseSkia();
var app = appBuilder.Build();
app.LoadLayout(new SourceCodeInfo("Box_Source", boxTemplate));
app.LoadLayout(new SourceCodeInfo("MyLayout_Source", layoutTemplate));
var factory = app.GetService <IComponentFactory>();
var windowComponent = factory.CreateComponent <WindowComponent>();
var window = (PlatformWindow)app.CreatePlatformWindow();
window.ComponentTree = windowComponent.ElementTree;
var styleSetter = (DssStyleSetter)app.GetService <IStyleSetter>();
styleSetter.ApplyFullStyleRecursivly(windowComponent.ElementTree);
app.Start(window);
}
public async Task BuildImplicitlyThrowsForMatchedEndpointAsLastStep()
{
var builder = new ApplicationBuilder(null);
var app = builder.Build();
var endpointCalled = false;
var endpoint = new Endpoint(
context =>
{
endpointCalled = true;
return(Task.CompletedTask);
},
EndpointMetadataCollection.Empty,
"Test endpoint");
var httpContext = new DefaultHttpContext();
httpContext.SetEndpoint(endpoint);
var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => app.Invoke(httpContext));
var expected =
"The request reached the end of the pipeline without executing the endpoint: 'Test endpoint'. " +
"Please register the EndpointMiddleware using 'IApplicationBuilder.UseEndpoints(...)' if " +
"using routing.";
Assert.Equal(expected, ex.Message);
Assert.False(endpointCalled);
}
public void Activate()
{
IApplicationBuilder appBuilder = new ApplicationBuilder(_serviceProvider);
appBuilder.Properties["host.AppName"] = _shellSettings.Name;
var orderedMiddlewares = _middlewareProviders
.SelectMany(p => p.GetMiddlewares())
.OrderBy(obj => obj.Priority);
foreach (var middleware in orderedMiddlewares)
{
middleware.Configure(appBuilder);
}
appBuilder.UseOrchard();
var pipeline = appBuilder.Build();
var allRoutes = new List <RouteDescriptor>();
allRoutes.AddRange(_routeProviders.SelectMany(provider => provider.GetRoutes()));
_routePublisher.Publish(allRoutes, pipeline);
}
public async Task UseOwin()
{
var serviceProvider = new ServiceCollection().BuildServiceProvider();
var builder = new ApplicationBuilder(serviceProvider);
IDictionary <string, object> environment = null;
var context = new DefaultHttpContext();
builder.UseOwin(addToPipeline =>
{
addToPipeline(next =>
{
Assert.NotNull(next);
return(async env =>
{
environment = env;
await next(env);
});
});
});
await builder.Build().Invoke(context);
// Dictionary contains context but does not contain "websocket.Accept" or "websocket.AcceptAlt" keys.
Assert.NotNull(environment);
var value = Assert.Single(
environment,
kvp => string.Equals(typeof(HttpContext).FullName, kvp.Key, StringComparison.Ordinal))
.Value;
Assert.Equal(context, value);
Assert.False(environment.ContainsKey("websocket.Accept"));
Assert.False(environment.ContainsKey("websocket.AcceptAlt"));
}
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 DefaultProtoContext();
// Act
await appFunc(httpContext);
// Assert
Assert.True(endpointRan);
}
public Task ActivatingAsync()
{
IApplicationBuilder appBuilder = new ApplicationBuilder(_serviceProvider);
var orderedMiddlewares = _middlewareProviders
.SelectMany(p => p.GetMiddlewares())
.OrderBy(obj => obj.Priority)
.ToArray();
RequestDelegate pipeline = null;
// If there are custom middleware for this tenant,
// build a custom pipeline for its routes
if (orderedMiddlewares.Length > 0)
{
foreach (var middleware in orderedMiddlewares)
{
middleware.Configure(appBuilder);
}
pipeline = appBuilder.Build();
}
_routePublisher.Publish(
_routeProviders.SelectMany(provider => provider.GetRoutes()),
pipeline
);
return(Task.CompletedTask);
}
//<inheritdoc />
public RequestDelegate CreatePipeline()
{
_logger.LogTrace("Creating new ApplicationBuilder.");
IApplicationBuilder app = new ApplicationBuilder(_serviceProvider);
app.Properties["host.AppName"] = _tenant.TenantId;
_logger.LogTrace("Registering middlewares.");
foreach (var middlewareProvider in _middlewareProviders)
{
middlewareProvider.Configure(app);
}
var routeBuilder = new RouteBuilder(app) { DefaultHandler = new MvcRouteHandler() };
_logger.LogDebug("Registering route providers.");
foreach (var routeProvider in _routeProviders.OrderBy(t => t.RouterPriority))
{
routeProvider.ConfigureRoutes(routeBuilder);
}
_logger.LogTrace("Building tenant router.");
app.UseRouter(routeBuilder.Build());
app.Run(async context =>
{
await context.Response.WriteAsync("You in tenant pipeline! " + _tenant.TenantId);
});
_logger.LogTrace("Building pipeline");
var pipeline = app.Build();
return pipeline;
}
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);
}
static void Main()
{
var ctx = new Context()
{
Message = "Context: Finished"
};
IApplicationBuilder builder = new ApplicationBuilder();
builder.Use(new Middleware1());
builder.Use(new Middleware2());
builder.Use(new Middleware3());
// Properties use to set values used by other middleware
builder.SetProperty("key", "Property Value");
Debug.WriteLine((string)builder.GetProperty("key"));
IApplication app = builder.Build();
app.Use((context, next) =>
{
Debug.WriteLine("Inline: Code executed before 'next'");
next(context);
Debug.WriteLine("Inline: Code executed after 'next'");
});
app.Invoke(ctx);
}
public void BuildDoesNotCallMatchedEndpointWhenTerminated()
{
var builder = new ApplicationBuilder(null);
builder.Run(context =>
{
// Do not call next
return(Task.CompletedTask);
});
var app = builder.Build();
var endpointCalled = false;
var endpoint = new Endpoint(
context =>
{
endpointCalled = true;
return(Task.CompletedTask);
},
EndpointMetadataCollection.Empty,
"Test endpoint");
var httpContext = new DefaultHttpContext();
httpContext.SetEndpoint(endpoint);
app.Invoke(httpContext);
Assert.False(endpointCalled);
}
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 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 GameSockets by default.
app(OwinGameSocketAcceptAdapter.AdaptGameSockets);
var builder = new ApplicationBuilder(serviceProvider: serviceProvider);
var middleware = CreateMiddlewareFactory(exit =>
{
builder.Use(ignored => exit);
return(builder.Build());
}, builder.ApplicationServices);
app(middleware);
return(builder);
}
public async Task UseGrpcWeb_CalledWithMatchingHttpContext_MiddlewareRuns()
{
// Arrange
var services = new ServiceCollection();
services.AddLogging();
var app = new ApplicationBuilder(services.BuildServiceProvider());
app.UseGrpcWeb(new GrpcWebOptions {
DefaultEnabled = true
});
var appFunc = app.Build();
var httpContext = new DefaultHttpContext();
httpContext.Request.Method = HttpMethods.Post;
httpContext.Request.ContentType = GrpcWebProtocolConstants.GrpcWebContentType;
// Act
await appFunc(httpContext);
// Assert
Assert.AreEqual(GrpcWebProtocolConstants.GrpcContentType, httpContext.Request.ContentType);
}
private RequestDelegate BuildTenantPipeline(TenantContext tenantContext)
{
var tenantServices = tenantContext.ServiceProvider;
var appBuilder = new ApplicationBuilder(tenantServices);
var routeBuilder = new RouteBuilder(appBuilder)
{
DefaultHandler = tenantServices.GetRequiredService <MvcRouteHandler>()
};
var startups = tenantServices.GetServices <IStartup>();
// IStartup instances are ordered by module dependency with an Order of 0 by default.
// OrderBy performs a stable sort so order is preserved among equal Order values.
startups.OrderBy(s => s.Order).Each(s => s.Configure(appBuilder, routeBuilder, tenantServices));
// use Tenant router
var router = routeBuilder.Build();
appBuilder.UseRouter(router);
// register root pipeline at the end of the tenant branch
appBuilder.Run(next);
return(appBuilder.Build());
}
public async Task InvokeAsync_ReplacesBodyNonJsonData()
{
// Our logic is based on the content-type, not the content.
// Since this is for text-plain content, we're going to encode it as a JSON string
// and store it in the data attribute - the middleware should JSON-decode it.
var input = "{ \"message\": \"hello, world\"}";
var expected = input;
var app = new ApplicationBuilder(null);
app.UseCloudEvents();
// Do verification in the scope of the middleware
app.Run(httpContext =>
{
httpContext.Request.ContentType.Should().Be("text/plain");
ReadBody(httpContext.Request.Body).Should().Be(expected);
return(Task.CompletedTask);
});
var pipeline = app.Build();
var context = new DefaultHttpContext();
context.Request.ContentType = "application/cloudevents+json";
context.Request.Body = MakeBody($"{{ \"datacontenttype\": \"text/plain\", \"data\": {JsonSerializer.Serialize(input)} }}");
await pipeline.Invoke(context);
}
public async Task UseGrpcWeb_RegisteredMultipleTimesCalledWithMatchingHttpContext_MiddlewareRuns()
{
// Arrange
var services = new ServiceCollection();
services.AddLogging();
var app = new ApplicationBuilder(services.BuildServiceProvider());
app.UseGrpcWeb(new GrpcWebOptions {
DefaultEnabled = true
});
app.UseGrpcWeb(new GrpcWebOptions {
DefaultEnabled = true
});
var appFunc = app.Build();
var httpContext = new DefaultHttpContext();
httpContext.Request.Method = HttpMethods.Post;
httpContext.Request.ContentType = GrpcWebProtocolConstants.GrpcWebContentType;
var testHttpResponseFeature = new TestHttpResponseFeature();
httpContext.Features.Set <IHttpResponseFeature>(testHttpResponseFeature);
// Act
await appFunc(httpContext);
// Assert
Assert.AreEqual(GrpcWebProtocolConstants.GrpcContentType, httpContext.Request.ContentType);
Assert.AreEqual(1, testHttpResponseFeature.StartingCallbackCount);
}
public async Task InvokeAsync_DataAndData64Set_ReturnsBadRequest()
{
var dataContentType = "application/octet-stream";
var app = new ApplicationBuilder(null);
app.UseCloudEvents();
var data = "{\"id\": \"1\"}";
// Do verification in the scope of the middleware
app.Run(httpContext =>
{
httpContext.Request.ContentType.Should().Be("application/json");
var body = ReadBody(httpContext.Request.Body);
body.Should().Equals(data);
return(Task.CompletedTask);
});
var pipeline = app.Build();
var context = new DefaultHttpContext();
context.Request.ContentType = "application/cloudevents+json";
var bytes = Encoding.UTF8.GetBytes(data);
var base64Str = System.Convert.ToBase64String(bytes);
context.Request.Body =
MakeBody($"{{ \"datacontenttype\": \"{dataContentType}\", \"data_base64\": \"{base64Str}\", \"data\": {data} }}");
await pipeline.Invoke(context);
context.Response.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
}
[InlineData("application/person+json", "UTF-16")] // arbitrary content type and charset
public async Task InvokeAsync_ReplacesBodyJson(string dataContentType, string charSet)
{
var encoding = charSet == null ? null : Encoding.GetEncoding(charSet);
var app = new ApplicationBuilder(null);
app.UseCloudEvents();
// Do verification in the scope of the middleware
app.Run(httpContext =>
{
httpContext.Request.ContentType.Should().Be(dataContentType ?? "application/json");
ReadBody(httpContext.Request.Body).Should().Be("{\"name\":\"jimmy\"}");
return(Task.CompletedTask);
});
var pipeline = app.Build();
var context = new DefaultHttpContext();
context.Request.ContentType = charSet == null ? "application/cloudevents+json" : $"application/cloudevents+json;charset={charSet}";
context.Request.Body = dataContentType == null?
MakeBody("{ \"data\": { \"name\":\"jimmy\" } }", encoding) :
MakeBody($"{{ \"datacontenttype\": \"{dataContentType}\", \"data\": {{ \"name\":\"jimmy\" }} }}", encoding);
await pipeline.Invoke(context);
}
public async Task InvokeAsync_ReadsBinaryData()
{
var dataContentType = "application/octet-stream";
var app = new ApplicationBuilder(null);
app.UseCloudEvents();
var data = new byte[] { 1, 2, 3 };
// Do verification in the scope of the middleware
app.Run(httpContext =>
{
httpContext.Request.ContentType.Should().Be(dataContentType);
var bytes = new byte[httpContext.Request.Body.Length];
httpContext.Request.Body.Read(bytes, 0, bytes.Length);
bytes.Should().Equal(data);
return(Task.CompletedTask);
});
var pipeline = app.Build();
var context = new DefaultHttpContext();
context.Request.ContentType = "application/cloudevents+json";
var base64Str = System.Convert.ToBase64String(data);
context.Request.Body =
MakeBody($"{{ \"datacontenttype\": \"{dataContentType}\", \"data_base64\": \"{base64Str}\"}}");
await pipeline.Invoke(context);
}
public async Task InvokeAsync_ReplacesBodyJson_NormalizesPayloadCharset()
{
var dataContentType = "application/person+json;charset=UTF-16";
var charSet = "UTF-16";
var encoding = Encoding.GetEncoding(charSet);
var app = new ApplicationBuilder(null);
app.UseCloudEvents();
// Do verification in the scope of the middleware
app.Run(httpContext =>
{
httpContext.Request.ContentType.Should().Be("application/person+json");
ReadBody(httpContext.Request.Body).Should().Be("{\"name\":\"jimmy\"}");
return(Task.CompletedTask);
});
var pipeline = app.Build();
var context = new DefaultHttpContext();
context.Request.ContentType = $"application/cloudevents+json;charset={charSet}";
context.Request.Body =
MakeBody($"{{ \"datacontenttype\": \"{dataContentType}\", \"data\": {{ \"name\":\"jimmy\" }} }}", encoding);
await pipeline.Invoke(context);
}
public async Task InvokeAsync_ReplacesBodyNonJsonData_ExceptWhenSuppressed()
{
// Our logic is based on the content-type, not the content. This test tests the old bad behavior.
var input = "{ \"message\": \"hello, world\"}";
var expected = JsonSerializer.Serialize(input);
var app = new ApplicationBuilder(null);
app.UseCloudEvents(new CloudEventsMiddlewareOptions()
{
SuppressJsonDecodingOfTextPayloads = true,
});
// Do verification in the scope of the middleware
app.Run(httpContext =>
{
httpContext.Request.ContentType.Should().Be("text/plain");
ReadBody(httpContext.Request.Body).Should().Be(expected);
return(Task.CompletedTask);
});
var pipeline = app.Build();
var context = new DefaultHttpContext();
context.Request.ContentType = "application/cloudevents+json";
context.Request.Body = MakeBody($"{{ \"datacontenttype\": \"text/plain\", \"data\": {JsonSerializer.Serialize(input)} }}");
await pipeline.Invoke(context);
}
public void UseMiddleware_MutlipleInvokeMethods_ThrowsException()
{
var mockServiceProvider = new DummyServiceProvider();
var builder = new ApplicationBuilder(mockServiceProvider);
builder.UseMiddleware(typeof(MiddlewareMultipleInvokesStub));
var exception = Assert.Throws<InvalidOperationException>(() => builder.Build());
Assert.Equal(Resources.FormatException_UseMiddleMutlipleInvokes("Invoke"), exception.Message);
}
public void UseMiddlewareWithInvokeArg()
{
var mockServiceProvider = new DummyServiceProvider();
var builder = new ApplicationBuilder(mockServiceProvider);
builder.UseMiddleware(typeof(MiddlewareInjectInvoke));
var app = builder.Build();
app(new DefaultHttpContext());
}
public void UseMiddleware_NonTaskReturnType_ThrowsException()
{
var mockServiceProvider = new DummyServiceProvider();
var builder = new ApplicationBuilder(mockServiceProvider);
builder.UseMiddleware(typeof(MiddlewareNonTaskReturnStub));
var exception = Assert.Throws<InvalidOperationException>(() => builder.Build());
Assert.Equal(Resources.FormatException_UseMiddlewareNonTaskReturnType("Invoke", nameof(Task)), exception.Message);
}
public void UseMiddleware_WithNoParameters_ThrowsException()
{
var mockServiceProvider = new DummyServiceProvider();
var builder = new ApplicationBuilder(mockServiceProvider);
builder.UseMiddleware(typeof(MiddlewareNoParametersStub));
var exception = Assert.Throws<InvalidOperationException>(() => builder.Build());
Assert.Equal(Resources.FormatException_UseMiddlewareNoParameters("Invoke", nameof(HttpContext)), exception.Message);
}
public async Task UseMiddleware_ThrowsIfArgCantBeResolvedFromContainer()
{
var mockServiceProvider = new DummyServiceProvider();
var builder = new ApplicationBuilder(mockServiceProvider);
builder.UseMiddleware(typeof(MiddlewareInjectInvokeNoService));
var app = builder.Build();
var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => app(new DefaultHttpContext()));
Assert.Equal(Resources.FormatException_InvokeMiddlewareNoService(typeof(object), typeof(MiddlewareInjectInvokeNoService)), exception.Message);
}
public void BuildReturnsCallableDelegate()
{
var builder = new ApplicationBuilder(null);
var app = builder.Build();
var httpContext = new DefaultHttpContext();
app.Invoke(httpContext);
Assert.Equal(httpContext.Response.StatusCode, 404);
}
public void PredicateTrueAction_BranchTaken()
{
HttpContext context = CreateRequest();
var builder = new ApplicationBuilder(serviceProvider: null);
builder.MapWhen(TruePredicate, UseSuccess);
var app = builder.Build();
app.Invoke(context).Wait();
Assert.Equal(200, context.Response.StatusCode);
}
public void PathMatchFunc_BranchTaken(string matchPath, string basePath, string requestPath)
{
HttpContext context = CreateRequest(basePath, requestPath);
var builder = new ApplicationBuilder(serviceProvider: null);
builder.Map(matchPath, UseSuccess);
var app = builder.Build();
app.Invoke(context).Wait();
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(basePath, context.Request.PathBase.Value);
Assert.Equal(requestPath, context.Request.Path.Value);
}
public void PathMatchAction_BranchTaken(string matchPath, string basePath, string requestPath)
{
HttpContext context = CreateRequest(basePath, requestPath);
var builder = new ApplicationBuilder(serviceProvider: null);
builder.Map(matchPath, subBuilder => subBuilder.Run(Success));
var app = builder.Build();
app.Invoke(context).Wait();
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(basePath + matchPath, context.Items["test.PathBase"]);
Assert.Equal(requestPath.Substring(matchPath.Length), context.Items["test.Path"]);
}
public ViewModelLocator()
{
var builder = new ApplicationBuilder();
container = builder.Build();
MainViewModel = container.Resolve<MainViewModel>();
}
public void ChainedPredicates_Success()
{
var builder = new ApplicationBuilder(serviceProvider: null);
builder.MapWhen(TruePredicate, map1 =>
{
map1.MapWhen((Predicate)FalsePredicate, UseNotImplemented);
map1.MapWhen((Predicate)TruePredicate, map2 => map2.MapWhen((Predicate)TruePredicate, UseSuccess));
map1.Run(NotImplemented);
});
var app = builder.Build();
HttpContext context = CreateRequest();
app.Invoke(context).Wait();
Assert.Equal(200, context.Response.StatusCode);
}
public void PredicateFalseAction_PassThrough()
{
HttpContext context = CreateRequest();
var builder = new ApplicationBuilder(serviceProvider: null);
builder.MapWhen(FalsePredicate, UseNotImplemented);
builder.Run(Success);
var app = builder.Build();
app.Invoke(context).Wait();
Assert.Equal(200, context.Response.StatusCode);
}
// Build the middleware pipeline for the current tenant
public RequestDelegate BuildTenantPipeline(ShellSettings shellSettings, IServiceProvider serviceProvider)
{
var startups = serviceProvider.GetServices<IStartup>();
var inlineConstraintResolver = serviceProvider.GetService<IInlineConstraintResolver>();
IApplicationBuilder appBuilder = new ApplicationBuilder(serviceProvider);
string routePrefix = "";
if (!string.IsNullOrWhiteSpace(shellSettings.RequestUrlPrefix))
{
routePrefix = shellSettings.RequestUrlPrefix + "/";
}
var routeBuilder = new RouteBuilder(appBuilder)
{
DefaultHandler = serviceProvider.GetRequiredService<MvcRouteHandler>()
};
var prefixedRouteBuilder = new PrefixedRouteBuilder(routePrefix, routeBuilder, inlineConstraintResolver);
// Register one top level TenantRoute per tenant. Each instance contains all the routes
// for this tenant.
// In the case of several tenants, they will all be checked by ShellSettings. To optimize
// the TenantRoute resolution we can create a single Router type that would index the
// TenantRoute object by their ShellSetting. This way there would just be one lookup.
// And the ShellSettings test in TenantRoute would also be useless.
foreach (var startup in startups)
{
startup.Configure(appBuilder, prefixedRouteBuilder, serviceProvider);
}
// The default route is added to each tenant as a template route, with a prefix
prefixedRouteBuilder.Routes.Add(new Route(
prefixedRouteBuilder.DefaultHandler,
"Default",
"{area:exists}/{controller}/{action}/{id?}",
null,
null,
null,
inlineConstraintResolver)
);
// Add home page route
routeBuilder.Routes.Add(new HomePageRoute(shellSettings.RequestUrlPrefix, routeBuilder, inlineConstraintResolver));
var router = prefixedRouteBuilder.Build();
appBuilder.UseRouter(router);
var pipeline = appBuilder.Build();
return pipeline;
}
public void PathMismatchAction_PassedThrough(string matchPath, string basePath, string requestPath)
{
HttpContext context = CreateRequest(basePath, requestPath);
var builder = new ApplicationBuilder(serviceProvider: null);
builder.Map(matchPath, UseNotImplemented);
builder.Run(Success);
var app = builder.Build();
app.Invoke(context).Wait();
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(basePath, context.Request.PathBase.Value);
Assert.Equal(requestPath, context.Request.Path.Value);
}
public void ChainedRoutes_Success()
{
var builder = new ApplicationBuilder(serviceProvider: null);
builder.Map("/route1", map =>
{
map.Map("/subroute1", UseSuccess);
map.Run(NotImplemented);
});
builder.Map("/route2/subroute2", UseSuccess);
var app = builder.Build();
HttpContext context = CreateRequest(string.Empty, "/route1");
Assert.Throws<AggregateException>(() => app.Invoke(context).Wait());
context = CreateRequest(string.Empty, "/route1/subroute1");
app.Invoke(context).Wait();
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(string.Empty, context.Request.PathBase.Value);
Assert.Equal("/route1/subroute1", context.Request.Path.Value);
context = CreateRequest(string.Empty, "/route2");
app.Invoke(context).Wait();
Assert.Equal(404, context.Response.StatusCode);
Assert.Equal(string.Empty, context.Request.PathBase.Value);
Assert.Equal("/route2", context.Request.Path.Value);
context = CreateRequest(string.Empty, "/route2/subroute2");
app.Invoke(context).Wait();
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(string.Empty, context.Request.PathBase.Value);
Assert.Equal("/route2/subroute2", context.Request.Path.Value);
context = CreateRequest(string.Empty, "/route2/subroute2/subsub2");
app.Invoke(context).Wait();
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(string.Empty, context.Request.PathBase.Value);
Assert.Equal("/route2/subroute2/subsub2", context.Request.Path.Value);
}
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;
}
