public async Task CanIncludeUserClaimsTest()
{
// Arrange
CreateContext(true);
var builder = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider);
var services = new ServiceCollection();
DbUtil.ConfigureDbServices<IdentityDbContext>(ConnectionString, services);
services.AddIdentity<IdentityUser, IdentityRole>().AddEntityFrameworkStores<IdentityDbContext>();
builder.ApplicationServices = services.BuildServiceProvider();
var userManager = builder.ApplicationServices.GetRequiredService<UserManager<IdentityUser>>();
var dbContext = builder.ApplicationServices.GetRequiredService<IdentityDbContext>();
var username = "******" + new Random().Next();
var user = new IdentityUser() { UserName = username };
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user));
for (var i = 0; i < 10; i++)
{
IdentityResultAssert.IsSuccess(await userManager.AddClaimAsync(user, new Claim(i.ToString(), "foo")));
}
user = dbContext.Users.Include(x => x.Claims).FirstOrDefault(x => x.UserName == username);
// Assert
Assert.NotNull(user);
Assert.NotNull(user.Claims);
Assert.Equal(10, user.Claims.Count());
}
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);
}
appBuilder.UseOrchard();
pipeline = appBuilder.Build();
}
_routePublisher.Publish(
_routeProviders.SelectMany(provider => provider.GetRoutes()),
pipeline
);
return Task.CompletedTask;
}
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 async Task ServicesArePerRequest()
{
var services = new ServiceCollection()
.AddScoped<ITestService, TestService>()
.BuildServiceProvider();
var builder = new ApplicationBuilder(services);
builder.Use(async (ctx, next) =>
{
var serviceScopeFactory = services.GetRequiredService<IServiceScopeFactory>();
using (var serviceScope = serviceScopeFactory.CreateScope())
{
var priorApplicationServices = ctx.ApplicationServices;
var priorRequestServices = ctx.ApplicationServices;
ctx.ApplicationServices = services;
ctx.RequestServices = serviceScope.ServiceProvider;
try
{
await next();
}
finally
{
ctx.ApplicationServices = priorApplicationServices;
ctx.RequestServices = priorRequestServices;
}
}
});
var testServicesA = new List<ITestService>();
builder.Use(async (HttpContext ctx, Func<Task> next, ITestService testService) =>
{
testServicesA.Add(testService);
await next();
});
var testServicesB = new List<ITestService>();
builder.Use<ITestService>(async (ctx, next, testService) =>
{
testServicesB.Add(testService);
await next();
});
var app = builder.Build();
await app(new DefaultHttpContext());
await app(new DefaultHttpContext());
Assert.Equal(2, testServicesA.Count);
Assert.IsType<TestService>(testServicesA[0]);
Assert.IsType<TestService>(testServicesA[1]);
Assert.Equal(2, testServicesB.Count);
Assert.IsType<TestService>(testServicesB[0]);
Assert.IsType<TestService>(testServicesB[1]);
Assert.Same(testServicesA[0], testServicesB[0]);
Assert.Same(testServicesA[1], testServicesB[1]);
Assert.NotSame(testServicesA[0], testServicesA[1]);
Assert.NotSame(testServicesB[0], testServicesB[1]);
}
public static void Configure(ApplicationBuilder app)
{
app.Run(context =>
{
return context.Response.WriteAsync("Hello World!");
});
}
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_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 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 void StartupClassCanHandleConfigureServicesThatReturnsNull()
{
var serviceCollection = new ServiceCollection();
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var startup = ApplicationStartup.LoadStartupMethods(services, "Microsoft.AspNet.Hosting.Tests", "WithNullConfigureServices", diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(new ServiceCollection());
Assert.NotNull(app.ApplicationServices);
startup.ConfigureDelegate(app);
Assert.NotNull(app.ApplicationServices);
}
public static IApplicationBuilder UseBuilder(this AddMiddleware app)
{
// Adapt WebSockets by default.
app(OwinWebSocketAcceptAdapter.AdaptWebSockets);
var builder = new ApplicationBuilder(serviceProvider: null);
CreateMiddleware middleware = CreateMiddlewareFactory(exit =>
{
builder.Use(ignored => exit);
return builder.Build();
});
app(middleware);
return builder;
}
public void StartupClassAddsConfigureServicesToApplicationServices(string environment)
{
var services = new ServiceCollection().BuildServiceProvider();
var diagnosticMesssages = new List<string>();
var startup = ApplicationStartup.LoadStartupMethods(services, "Microsoft.AspNet.Hosting.Tests", environment ?? "", diagnosticMesssages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(new ServiceCollection());
startup.ConfigureDelegate(app);
var options = app.ApplicationServices.GetRequiredService<IOptions<FakeOptions>>().Options;
Assert.NotNull(options);
Assert.True(options.Configured);
Assert.Equal(environment, options.Environment);
}
public void StartupClassCanHandleConfigureServicesThatReturnsNull()
{
var serviceCollection = new ServiceCollection();
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = "WithNullConfigureServices" };
var loader = new StartupLoader(services, hostingEnv);
var type = loader.FindStartupType("Microsoft.AspNet.Hosting.Tests", diagnosticMessages);
var startup = loader.LoadMethods(type, diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(new ServiceCollection());
Assert.NotNull(app.ApplicationServices);
startup.ConfigureDelegate(app);
Assert.NotNull(app.ApplicationServices);
}
public async Task Main(string[] args)
{
var app = new ApplicationBuilder(_serviceProvider);
var payload = Encoding.UTF8.GetBytes("HelloWorld");
app.Run(context =>
{
return context.Response.Body.WriteAsync(payload, 0, payload.Length);
});
var requestDelegate = app.Build();
#if DNX451
Console.WriteLine($"Hit Enter to start test, PID {Process.GetCurrentProcess().Id}");
Console.ReadLine();
#endif
var requestCount = 5000000;
var started = DateTime.UtcNow;
var userAgent = new KeyValuePair<string, string[]>("User-Agent", new[] { "InlineTest" });
for (int i = 0; i < requestCount; i++)
{
var httpContext = new DefaultHttpContext();
//httpContext.Request.Method = "GET";
httpContext.Request.Headers.Add(userAgent);
//httpContext.Request.Headers.Add("Accept", new[] { "text/html;text/plain" });
await requestDelegate(httpContext);
}
var elapsed = DateTime.UtcNow - started;
Console.WriteLine($"Completed {requestCount} requests in {elapsed}");
Console.WriteLine($"Requests/sec: {requestCount/elapsed.TotalSeconds}");
Console.WriteLine("Hit Enter to force a GC");
Console.ReadLine();
Console.Write("GC started...");
GC.Collect();
Console.WriteLine("finished!");
Console.WriteLine();
Console.ReadLine();
}
public async Task CallingUseThatAlsoTakesServices()
{
var builder = new ApplicationBuilder(new ServiceCollection()
.AddScoped<ITestService, TestService>()
.BuildServiceProvider());
ITestService theService = null;
builder.Use<ITestService>(async (ctx, next, testService) =>
{
theService = testService;
await next();
});
var app = builder.Build();
await app(new DefaultHttpContext());
Assert.IsType<TestService>(theService);
}
public void StartupClassMayHaveHostingServicesInjected()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddInstance<IFakeStartupCallback>(this);
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = "WithServices" };
var loader = new StartupLoader(services, hostingEnv);
var type = loader.FindStartupType("Microsoft.AspNet.Hosting.Tests", diagnosticMessages);
var startup = loader.LoadMethods(type, diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection);
startup.ConfigureDelegate(app);
Assert.Equal(2, _configurationMethodCalledList.Count);
}
public void StartupClassAddsConfigureServicesToApplicationServices(string environment)
{
var services = new ServiceCollection().BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = environment };
var loader = new StartupLoader(services, hostingEnv);
var type = loader.FindStartupType("Microsoft.AspNet.Hosting.Tests", diagnosticMessages);
var startup = loader.LoadMethods(type, diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(new ServiceCollection());
startup.ConfigureDelegate(app);
var options = app.ApplicationServices.GetRequiredService<IOptions<FakeOptions>>().Value;
Assert.NotNull(options);
Assert.True(options.Configured);
Assert.Equal(environment, options.Environment);
}
public async Task VerifyAccountControllerSignIn(bool isPersistent)
{
var app = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider);
app.UseCookieAuthentication();
var context = new Mock<HttpContext>();
var auth = new Mock<AuthenticationManager>();
context.Setup(c => c.Authentication).Returns(auth.Object).Verifiable();
auth.Setup(a => a.SignInAsync(new IdentityCookieOptions().ApplicationCookieAuthenticationScheme,
It.IsAny<ClaimsPrincipal>(),
It.IsAny<AuthenticationProperties>())).Returns(Task.FromResult(0)).Verifiable();
// REVIEW: is persistant mocking broken
//It.Is<AuthenticationProperties>(v => v.IsPersistent == isPersistent))).Returns(Task.FromResult(0)).Verifiable();
var contextAccessor = new Mock<IHttpContextAccessor>();
contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
var services = new ServiceCollection();
services.AddLogging();
services.AddInstance(contextAccessor.Object);
services.AddIdentity<TestUser, TestRole>();
services.AddSingleton<IUserStore<TestUser>, InMemoryUserStore<TestUser>>();
services.AddSingleton<IRoleStore<TestRole>, InMemoryRoleStore<TestRole>>();
app.ApplicationServices = services.BuildServiceProvider();
// Act
var user = new TestUser
{
UserName = "******"
};
const string password = "******";
var userManager = app.ApplicationServices.GetRequiredService<UserManager<TestUser>>();
var signInManager = app.ApplicationServices.GetRequiredService<SignInManager<TestUser>>();
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password));
var result = await signInManager.PasswordSignInAsync(user, password, isPersistent, false);
// Assert
Assert.True(result.Succeeded);
context.VerifyAll();
auth.VerifyAll();
contextAccessor.VerifyAll();
}
public async Task EnsureStartupUsageWorks()
{
var context = CreateContext(true);
var builder = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider);
var services = new ServiceCollection();
DbUtil.ConfigureDbServices<IdentityDbContext>(ConnectionString, services);
services.AddIdentity<IdentityUser, IdentityRole>().AddEntityFrameworkStores<IdentityDbContext>();
builder.ApplicationServices = services.BuildServiceProvider();
var userStore = builder.ApplicationServices.GetRequiredService<IUserStore<IdentityUser>>();
var userManager = builder.ApplicationServices.GetRequiredService<UserManager<IdentityUser>>();
Assert.NotNull(userStore);
Assert.NotNull(userManager);
const string userName = "******";
const string password = "******";
var user = new IdentityUser { UserName = userName };
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password));
IdentityResultAssert.IsSuccess(await userManager.DeleteAsync(user));
}
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 CanIncludeRoleClaimsTest()
{
// Arrange
CreateContext(true);
var builder = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider);
var services = new ServiceCollection();
DbUtil.ConfigureDbServices<IdentityDbContext>(ConnectionString, services);
services.AddIdentity<IdentityUser, IdentityRole>().AddEntityFrameworkStores<IdentityDbContext>();
builder.ApplicationServices = services.BuildServiceProvider();
var roleManager = builder.ApplicationServices.GetRequiredService<RoleManager<IdentityRole>>();
var dbContext = builder.ApplicationServices.GetRequiredService<IdentityDbContext>();
var role = new IdentityRole("Admin");
IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(role));
for (var i = 0; i < 10; i++)
{
IdentityResultAssert.IsSuccess(await roleManager.AddClaimAsync(role, new Claim("foo" + i, "bar" + i)));
}
role = dbContext.Roles.Include(x => x.Claims).FirstOrDefault(x => x.Name == "Admin");
// Assert
Assert.NotNull(role);
Assert.NotNull(role.Claims);
Assert.Equal(10, role.Claims.Count());
}
public void StartupClassWithConfigureServicesShouldMakeServiceAvailableInConfigure()
{
var serviceCollection = new ServiceCollection();
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var startup = ApplicationStartup.LoadStartupMethods(services, "Microsoft.AspNet.Hosting.Tests", "WithConfigureServices", diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection);
startup.ConfigureDelegate(app);
var foo = app.ApplicationServices.GetRequiredService<StartupWithConfigureServices.IFoo>();
Assert.True(foo.Invoked);
}
public void StartupClassMayHaveHostingServicesInjected()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddInstance<IFakeStartupCallback>(this);
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var startup = ApplicationStartup.LoadStartupMethods(services, "Microsoft.AspNet.Hosting.Tests", "WithServices", diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection);
startup.ConfigureDelegate(app);
Assert.Equal(2, _configurationMethodCalledList.Count);
}
public void StartupLoaderCanLoadByType()
{
var serviceCollection = new ServiceCollection();
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment();
var loader = new StartupLoader(services, hostingEnv);
var startup = loader.LoadMethods(typeof(TestStartup), diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection);
startup.ConfigureDelegate(app);
var foo = app.ApplicationServices.GetRequiredService<SimpleService>();
Assert.Equal("Configure", foo.Message);
}
public void StartupLoaderCanLoadByTypeWithEnvironment()
{
var serviceCollection = new ServiceCollection();
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = "No" };
var loader = new StartupLoader(services, hostingEnv);
var startup = loader.LoadMethods(typeof(TestStartup), diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection);
var ex = Assert.Throws<TargetInvocationException>(() => startup.ConfigureDelegate(app));
Assert.IsAssignableFrom(typeof(InvalidOperationException), ex.InnerException);
}
public static void Run(string[] args, Action<ApplicationBuilder> config)
{
// Build middleware pipeline
var appBuilder = new ApplicationBuilder();
config(appBuilder);
var appDelegate = appBuilder.Build();
var loop = new UVLoop();
var listener = new TcpListener("0.0.0.0", 5000, loop);
listener.ConnectionAccepted += (Tcp connection) =>
{
connection.ReadCompleted += (ByteSpan data) =>
{
//unsafe
//{
// var requestString = Encoding.UTF8.GetString(data.UnsafeBuffer, data.Length);
// Console.WriteLine("*REQUEST:\n {0}", requestString.ToString());
//}
var context = new LibuvHttpContext();
// BAD: Single threaded for now, we're ignoring the result of the task
// because we know it's synchronous
appDelegate(context);
context.Response.ContentType = context.Response.ContentType ?? "text/plain";
if (context.Response.StatusCode == 0)
{
context.Response.StatusCode = 200;
}
// Flush and dispose (keep alive not supported)
var contentLength = (int)context.Response.ContentLength;
var responseBuffer = new byte[1024];
var written = 0;
Append(responseBuffer, ref written, "HTTP/1.1 ");
Append(responseBuffer, ref written, context.Response.StatusCode);
Append(responseBuffer, ref written, " ");
Append(responseBuffer, ref written, GetStatusText(context.Response.StatusCode));
Append(responseBuffer, ref written, "\r\n");
Append(responseBuffer, ref written, "Content-Length:");
Append(responseBuffer, ref written, contentLength);
Append(responseBuffer, ref written, "\r\n");
Append(responseBuffer, ref written, "Content-Type:");
Append(responseBuffer, ref written, context.Response.ContentType);
Append(responseBuffer, ref written, "\r\n");
Append(responseBuffer, ref written, "Connection:Close\r\n\r\n");
Append(responseBuffer, ref written, ((LibuvStream)context.Response.Body).GetBuffer());
connection.TryWrite(responseBuffer, written);
connection.Dispose();
};
connection.ReadStart();
};
listener.Listen();
// Console.WriteLine("Listening on ::5000");
loop.Run();
}
private ApplicationBuilder(ApplicationBuilder builder)
{
Properties = builder.Properties;
}
public async Task CanIncludeUserRolesTest()
{
// Arrange
CreateContext(true);
var builder = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider);
var services = new ServiceCollection();
DbUtil.ConfigureDbServices<IdentityDbContext>(ConnectionString, services);
services.AddIdentity<IdentityUser, IdentityRole>().AddEntityFrameworkStores<IdentityDbContext>();
builder.ApplicationServices = services.BuildServiceProvider();
var userManager = builder.ApplicationServices.GetRequiredService<UserManager<IdentityUser>>();
var roleManager = builder.ApplicationServices.GetRequiredService<RoleManager<IdentityRole>>();
var dbContext = builder.ApplicationServices.GetRequiredService<IdentityDbContext>();
const string roleName = "Admin";
for (var i = 0; i < 10; i++)
{
IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(new IdentityRole(roleName + i)));
}
var username = "******" + new Random().Next();
var user = new IdentityUser() { UserName = username };
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user));
for (var i = 0; i < 10; i++)
{
IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(user, roleName + i));
}
user = dbContext.Users.Include(x => x.Roles).FirstOrDefault(x => x.UserName == username);
// Assert
Assert.NotNull(user);
Assert.NotNull(user.Roles);
Assert.Equal(10, user.Roles.Count());
for (var i = 0; i < 10; i++)
{
var role = dbContext.Roles.Include(r => r.Users).FirstOrDefault(r => r.Name == (roleName + i));
Assert.NotNull(role);
Assert.NotNull(role.Users);
Assert.Equal(1, role.Users.Count());
}
}
public void StartupClassWithConfigureServicesShouldMakeServiceAvailableInConfigure()
{
var serviceCollection = new ServiceCollection();
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = "WithConfigureServices" };
var loader = new StartupLoader(services, hostingEnv);
var type = loader.FindStartupType("Microsoft.AspNet.Hosting.Tests", diagnosticMessages);
var startup = loader.LoadMethods(type, diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection);
startup.ConfigureDelegate(app);
var foo = app.ApplicationServices.GetRequiredService<StartupWithConfigureServices.IFoo>();
Assert.True(foo.Invoked);
}
public async Task InvokeMethodWillAllowPerRequestServices()
{
var services = new ServiceCollection()
.AddScoped<ITestService, TestService>()
.BuildServiceProvider();
var builder = new ApplicationBuilder(services);
builder.UseMiddleware<TestMiddleware>();
var app = builder.Build();
var ctx1 = new DefaultHttpContext();
await app(ctx1);
var testService = ctx1.Items[typeof(ITestService)];
Assert.IsType<TestService>(testService);
}
