376 lines
20 KiB
C#
376 lines
20 KiB
C#
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
|
|
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
|
|
|
|
using Microsoft.AspNet.Builder;
|
|
using Microsoft.AspNet.Identity.Test;
|
|
using Microsoft.AspNet.Testing;
|
|
using Microsoft.Data.Entity;
|
|
using Microsoft.Framework.DependencyInjection;
|
|
using Microsoft.Framework.DependencyInjection.Fallback;
|
|
using Microsoft.Framework.OptionsModel;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Security.Claims;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Xunit;
|
|
|
|
namespace Microsoft.AspNet.Identity.SqlServer.Test
|
|
{
|
|
[TestCaseOrderer("Microsoft.AspNet.Identity.Test.PriorityOrderer", "Microsoft.AspNet.Identity.SqlServer.Test")]
|
|
public class UserStoreTest : UserManagerTestBase<IdentityUser, IdentityRole>
|
|
{
|
|
private readonly string ConnectionString = @"Server=(localdb)\v11.0;Database=SqlUserStoreTest" + DateTime.Now.Month + "-" + DateTime.Now.Day + "-" + DateTime.Now.Year + ";Trusted_Connection=True;";
|
|
|
|
public class ApplicationUser : IdentityUser { }
|
|
|
|
public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
|
|
{
|
|
public ApplicationDbContext(IServiceProvider services, IOptionsAccessor<DbContextOptions> options) : base(services, options.Options) { }
|
|
}
|
|
|
|
[TestPriority(-1000)]
|
|
[Fact]
|
|
public void DropDatabaseStart()
|
|
{
|
|
DropDb();
|
|
}
|
|
|
|
[TestPriority(10000)]
|
|
[Fact]
|
|
public void DropDatabaseDone()
|
|
{
|
|
DropDb();
|
|
}
|
|
|
|
public void DropDb()
|
|
{
|
|
var services = new ServiceCollection();
|
|
services.AddEntityFramework().AddSqlServer();
|
|
services.Add(OptionsServices.GetDefaultServices());
|
|
services.SetupOptions<DbContextOptions>(options =>
|
|
options.UseSqlServer(ConnectionString));
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
var db = new ApplicationDbContext(serviceProvider,
|
|
serviceProvider.GetService<IOptionsAccessor<DbContextOptions>>());
|
|
db.Database.EnsureDeleted();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task EnsureStartupUsageWorks()
|
|
{
|
|
EnsureDatabase();
|
|
var builder = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
|
|
|
|
builder.UseServices(services =>
|
|
{
|
|
services.AddEntityFramework().AddSqlServer();
|
|
services.AddIdentitySqlServer<ApplicationDbContext, ApplicationUser>();
|
|
services.SetupOptions<DbContextOptions>(options =>
|
|
options.UseSqlServer(ConnectionString));
|
|
});
|
|
|
|
var userStore = builder.ApplicationServices.GetService<IUserStore<ApplicationUser>>();
|
|
var userManager = builder.ApplicationServices.GetService<UserManager<ApplicationUser>>();
|
|
|
|
Assert.NotNull(userStore);
|
|
Assert.NotNull(userManager);
|
|
|
|
const string userName = "admin";
|
|
const string password = "1qaz@WSX";
|
|
var user = new ApplicationUser { UserName = userName };
|
|
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password));
|
|
IdentityResultAssert.IsSuccess(await userManager.DeleteAsync(user));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task EnsureStartupOptionsChangeWorks()
|
|
{
|
|
EnsureDatabase();
|
|
var builder = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
|
|
|
|
builder.UseServices(services =>
|
|
{
|
|
services.AddEntityFramework().AddSqlServer();
|
|
services.AddIdentitySqlServer<ApplicationDbContext, ApplicationUser>().SetupOptions(options =>
|
|
{
|
|
options.Password.RequiredLength = 1;
|
|
options.Password.RequireLowercase = false;
|
|
options.Password.RequireNonLetterOrDigit = false;
|
|
options.Password.RequireUppercase = false;
|
|
options.Password.RequireDigit = false;
|
|
});
|
|
services.SetupOptions<DbContextOptions>(options =>
|
|
options.UseSqlServer(ConnectionString));
|
|
});
|
|
|
|
var userStore = builder.ApplicationServices.GetService<IUserStore<ApplicationUser>>();
|
|
var userManager = builder.ApplicationServices.GetService<UserManager<ApplicationUser>>();
|
|
|
|
Assert.NotNull(userStore);
|
|
Assert.NotNull(userManager);
|
|
|
|
const string userName = "admin";
|
|
const string password = "a";
|
|
var user = new ApplicationUser { UserName = userName };
|
|
IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password));
|
|
IdentityResultAssert.IsSuccess(await userManager.DeleteAsync(user));
|
|
}
|
|
|
|
[Fact]
|
|
public void CanCreateUserUsingEF()
|
|
{
|
|
using (var db = CreateContext())
|
|
{
|
|
var guid = Guid.NewGuid().ToString();
|
|
db.Users.Add(new IdentityUser {Id = guid, UserName = guid});
|
|
db.SaveChanges();
|
|
Assert.True(db.Users.Any(u => u.UserName == guid));
|
|
Assert.NotNull(db.Users.FirstOrDefault(u => u.UserName == guid));
|
|
}
|
|
}
|
|
|
|
public IdentityDbContext CreateContext(bool delete = false)
|
|
{
|
|
var services = new ServiceCollection();
|
|
services.AddEntityFramework().AddSqlServer();
|
|
var dbOptions = new DbContextOptions();
|
|
dbOptions.UseSqlServer(ConnectionString);
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
var db = new IdentityDbContext(serviceProvider, dbOptions);
|
|
if (delete)
|
|
{
|
|
db.Database.EnsureDeleted();
|
|
}
|
|
db.Database.EnsureCreated();
|
|
return db;
|
|
}
|
|
|
|
protected override object CreateTestContext()
|
|
{
|
|
return CreateContext();
|
|
}
|
|
|
|
public void EnsureDatabase()
|
|
{
|
|
CreateContext();
|
|
}
|
|
|
|
public ApplicationDbContext CreateAppContext()
|
|
{
|
|
CreateContext();
|
|
var services = new ServiceCollection();
|
|
services.AddEntityFramework().AddSqlServer();
|
|
services.Add(OptionsServices.GetDefaultServices());
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
|
|
var db = new ApplicationDbContext(serviceProvider, serviceProvider.GetService<IOptionsAccessor<DbContextOptions>>());
|
|
db.Database.EnsureCreated();
|
|
return db;
|
|
}
|
|
|
|
public static UserManager<IdentityUser> CreateManager(DbContext context)
|
|
{
|
|
return MockHelpers.CreateManager(new UserStore<IdentityUser>(context));
|
|
}
|
|
|
|
protected override UserManager<IdentityUser> CreateManager(object context = null)
|
|
{
|
|
if (context == null)
|
|
{
|
|
context = CreateTestContext();
|
|
}
|
|
return CreateManager((DbContext)context);
|
|
}
|
|
|
|
public static RoleManager<IdentityRole> CreateRoleManager(IdentityDbContext context)
|
|
{
|
|
var services = new ServiceCollection();
|
|
services.AddIdentity().AddRoleStore(new RoleStore<IdentityRole>(context));
|
|
return services.BuildServiceProvider().GetService<RoleManager<IdentityRole>>();
|
|
}
|
|
|
|
protected override RoleManager<IdentityRole> CreateRoleManager(object context)
|
|
{
|
|
if (context == null)
|
|
{
|
|
context = CreateTestContext();
|
|
}
|
|
return CreateRoleManager((IdentityDbContext)context);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task SqlUserStoreMethodsThrowWhenDisposedTest()
|
|
{
|
|
var store = new UserStore(new IdentityDbContext());
|
|
store.Dispose();
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.AddClaimsAsync(null, null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.AddLoginAsync(null, null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.AddToRoleAsync(null, null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.GetClaimsAsync(null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.GetLoginsAsync(null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.GetRolesAsync(null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.IsInRoleAsync(null, null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.RemoveClaimsAsync(null, null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.RemoveLoginAsync(null, null, null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(
|
|
async () => await store.RemoveFromRoleAsync(null, null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.RemoveClaimsAsync(null, null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.FindByLoginAsync(null, null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.FindByIdAsync(null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.FindByNameAsync(null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.CreateAsync(null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.UpdateAsync(null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.DeleteAsync(null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(
|
|
async () => await store.SetEmailConfirmedAsync(null, true));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.GetEmailConfirmedAsync(null));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(
|
|
async () => await store.SetPhoneNumberConfirmedAsync(null, true));
|
|
await Assert.ThrowsAsync<ObjectDisposedException>(
|
|
async () => await store.GetPhoneNumberConfirmedAsync(null));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UserStorePublicNullCheckTest()
|
|
{
|
|
Assert.Throws<ArgumentNullException>("context", () => new UserStore(null));
|
|
var store = new UserStore(new IdentityDbContext());
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetUserIdAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetUserNameAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.SetUserNameAsync(null, null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.CreateAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.UpdateAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.DeleteAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.AddClaimsAsync(null, null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.RemoveClaimsAsync(null, null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetClaimsAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetLoginsAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetRolesAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.AddLoginAsync(null, null));
|
|
await
|
|
Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.RemoveLoginAsync(null, null, null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.AddToRoleAsync(null, null));
|
|
await
|
|
Assert.ThrowsAsync<ArgumentNullException>("user",
|
|
async () => await store.RemoveFromRoleAsync(null, null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.IsInRoleAsync(null, null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetPasswordHashAsync(null));
|
|
await
|
|
Assert.ThrowsAsync<ArgumentNullException>("user",
|
|
async () => await store.SetPasswordHashAsync(null, null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetSecurityStampAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user",
|
|
async () => await store.SetSecurityStampAsync(null, null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("login", async () => await store.AddLoginAsync(new IdentityUser("fake"), null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("claims",
|
|
async () => await store.AddClaimsAsync(new IdentityUser("fake"), null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("claims",
|
|
async () => await store.RemoveClaimsAsync(new IdentityUser("fake"), null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetEmailConfirmedAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user",
|
|
async () => await store.SetEmailConfirmedAsync(null, true));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetEmailAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.SetEmailAsync(null, null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetPhoneNumberAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.SetPhoneNumberAsync(null, null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user",
|
|
async () => await store.GetPhoneNumberConfirmedAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user",
|
|
async () => await store.SetPhoneNumberConfirmedAsync(null, true));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetTwoFactorEnabledAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user",
|
|
async () => await store.SetTwoFactorEnabledAsync(null, true));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetAccessFailedCountAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetLockoutEnabledAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.SetLockoutEnabledAsync(null, false));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.GetLockoutEndDateAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.SetLockoutEndDateAsync(null, new DateTimeOffset()));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.ResetAccessFailedCountAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentNullException>("user", async () => await store.IncrementAccessFailedCountAsync(null));
|
|
await Assert.ThrowsAsync<ArgumentException>("roleName", async () => await store.AddToRoleAsync(new IdentityUser("fake"), null));
|
|
await Assert.ThrowsAsync<ArgumentException>("roleName", async () => await store.RemoveFromRoleAsync(new IdentityUser("fake"), null));
|
|
await Assert.ThrowsAsync<ArgumentException>("roleName", async () => await store.IsInRoleAsync(new IdentityUser("fake"), null));
|
|
await Assert.ThrowsAsync<ArgumentException>("roleName", async () => await store.AddToRoleAsync(new IdentityUser("fake"), ""));
|
|
await Assert.ThrowsAsync<ArgumentException>("roleName", async () => await store.RemoveFromRoleAsync(new IdentityUser("fake"), ""));
|
|
await Assert.ThrowsAsync<ArgumentException>("roleName", async () => await store.IsInRoleAsync(new IdentityUser("fake"), ""));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CanCreateUsingManager()
|
|
{
|
|
var manager = CreateManager();
|
|
var guid = Guid.NewGuid().ToString();
|
|
var user = new IdentityUser { UserName = "New"+guid };
|
|
IdentityResultAssert.IsSuccess(await manager.CreateAsync(user));
|
|
IdentityResultAssert.IsSuccess(await manager.DeleteAsync(user));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task EnsureRoleClaimNavigationProperty()
|
|
{
|
|
var context = CreateContext();
|
|
var roleManager = CreateRoleManager(context);
|
|
var r = new IdentityRole("EnsureRoleClaimNavigationProperty");
|
|
IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(r));
|
|
var c = new Claim("a", "b");
|
|
IdentityResultAssert.IsSuccess(await roleManager.AddClaimAsync(r, c));
|
|
Assert.NotNull(r.Claims.Single(cl => cl.ClaimValue == c.Value && cl.ClaimType == c.Type));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task AddUserToUnknownRoleFails()
|
|
{
|
|
var manager = CreateManager();
|
|
var u = CreateTestUser();
|
|
IdentityResultAssert.IsSuccess(await manager.CreateAsync(u));
|
|
await Assert.ThrowsAsync<InvalidOperationException>(
|
|
async () => await manager.AddToRoleAsync(u, "bogus"));
|
|
}
|
|
|
|
// TODO: can we move these to UserManagerTestBase?
|
|
[Fact]
|
|
public async Task DeleteRoleNonEmptySucceedsTest()
|
|
{
|
|
// Need fail if not empty?
|
|
var context = CreateTestContext();
|
|
var userMgr = CreateManager(context);
|
|
var roleMgr = CreateRoleManager(context);
|
|
var role = new IdentityRole("deleteNonEmpty");
|
|
Assert.False(await roleMgr.RoleExistsAsync(role.Name));
|
|
IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role));
|
|
var user = new IdentityUser("t");
|
|
IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user));
|
|
IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name));
|
|
var roles = await userMgr.GetRolesAsync(user);
|
|
Assert.Equal(1, roles.Count());
|
|
IdentityResultAssert.IsSuccess(await roleMgr.DeleteAsync(role));
|
|
Assert.Null(await roleMgr.FindByNameAsync(role.Name));
|
|
Assert.False(await roleMgr.RoleExistsAsync(role.Name));
|
|
// REVIEW: We should throw if deleteing a non empty role?
|
|
roles = await userMgr.GetRolesAsync(user);
|
|
|
|
Assert.Equal(0, roles.Count());
|
|
}
|
|
|
|
// TODO: cascading deletes? navigation properties not working
|
|
//[Fact]
|
|
//public async Task DeleteUserRemovesFromRoleTest()
|
|
//{
|
|
// // Need fail if not empty?
|
|
// var userMgr = CreateManager();
|
|
// var roleMgr = CreateRoleManager();
|
|
// var role = new IdentityRole("deleteNonEmpty");
|
|
// Assert.False(await roleMgr.RoleExistsAsync(role.Name));
|
|
// IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role));
|
|
// var user = new IdentityUser("t");
|
|
// IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user));
|
|
// IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name));
|
|
// Assert.Equal(1, role.Users.Count);
|
|
// IdentityResultAssert.IsSuccess(await userMgr.DeleteAsync(user));
|
|
// role = await roleMgr.FindByIdAsync(role.Id);
|
|
// Assert.Equal(0, role.Users.Count);
|
|
//}
|
|
}
|
|
} |