public async Task OnPostAsync_InvalidModel()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
IActionResult post;
var client = new Client {
Id = Random.Next()
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
var claims = new ClaimsModel(context)
{
Client = new Client {
Id = Random.Next()
}
};
post = await claims.OnPostAsync().ConfigureAwait(false);
}
// Assert
Assert.IsType <PageResult>(post);
}
public async Task OnPostAsync_AllRemoved()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_AllRemoved)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
ClaimsModel claims;
IActionResult post;
var client = new Client
{
Id = Random.Next(),
Claims = new List <ClientClaim>
{
new ClientClaim {
Id = Random.Next()
}
}
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
claims = new ClaimsModel(context)
{
Client = new Client {
Id = client.Id
}
};
post = await claims.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
client = await context.Clients
.Include(x => x.Claims)
.SingleOrDefaultAsync(x => x.Id.Equals(client.Id))
.ConfigureAwait(false);
Assert.Empty(client.Claims);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Client.Id), key);
Assert.Equal(claims.Client.Id, value);
});
}
public async Task OnPostAsync_AllRemoved()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_AllRemoved)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var userClaim = new UserClaim
{
ClaimType = "Claim Type",
ClaimValue = "Claim Value"
};
var user = new User
{
Email = "Email",
Claims = new List <UserClaim> {
userClaim
}
};
using (var context = new OidcDbContext(options))
{
context.Add(user);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_userManager.Setup(x => x.Users).Returns(context.Users);
var model = new ClaimsModel(_userManager.Object)
{
UserModel = new User {
Id = user.Id
}
};
get = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_userManager.Verify(
x => x.RemoveClaimsAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <IEnumerable <Claim> >(y => y.SingleOrDefault(z => z.Type.Equals(userClaim.ClaimType) && z.Value.Equals(userClaim.ClaimValue)) != null)),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(get);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(User.Id), key);
Assert.Equal(user.Id, value);
});
}
public async Task OnPostAsync_AllRemoved()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_AllRemoved)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var roleClaim = new RoleClaim
{
ClaimType = "Claim Type",
ClaimValue = "Claim Value"
};
var role = new Role
{
Name = "Role Name",
RoleClaims = new List <RoleClaim> {
roleClaim
}
};
using (var context = new OidcDbContext(options))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
var model = new ClaimsModel(_roleManager.Object)
{
Role = new Role {
Id = role.Id
}
};
get = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_roleManager.Verify(
x => x.RemoveClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(roleClaim.ClaimType) && y.Value.Equals(roleClaim.ClaimValue))),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(get);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Role.Id), key);
Assert.Equal(role.Id, value);
});
}
public async Task OnPostAsync_InvalidId()
{
// Arrange
var context = new Mock <IConfigurationDbContext>();
var claims = new ClaimsModel(context.Object)
{
Client = new Client {
Id = 0
}
};
// Act
var post = await claims.OnPostAsync().ConfigureAwait(false);
// Assert
context.Verify(x => x.SaveChangesAsync(), Times.Never);
Assert.IsType <PageResult>(post);
}
public async Task OnPostAsync_InvalidModel()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_InvalidModel)}";
var options = new DbContextOptionsBuilder <IdentityServerDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var role = new Role {
Id = Guid.NewGuid()
};
var id = Guid.NewGuid();
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult post;
// Act
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
var model = new ClaimsModel(_roleManager.Object)
{
Role = new Role {
Id = id
}
};
post = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_roleManager.Verify(x => x.UpdateAsync(It.IsAny <Role>()), Times.Never);
Assert.IsType <PageResult>(post);
}
public async Task OnPostAsync_InvalidModel()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_InvalidModel)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var user = new User {
Id = Guid.NewGuid()
};
var id = Guid.NewGuid();
using (var context = new OidcDbContext(options))
{
context.Add(user);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult post;
// Act
using (var context = new OidcDbContext(options))
{
_userManager.Setup(x => x.Users).Returns(context.Users);
var model = new ClaimsModel(_userManager.Object)
{
UserModel = new User {
Id = id
}
};
post = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_userManager.Verify(x => x.UpdateAsync(It.IsAny <User>()), Times.Never);
Assert.IsType <PageResult>(post);
}
public async Task OnPostAsync()
{
// Arrange
const string originalRoleClaim2Type = "Claim 2 Type";
const string newRoleClaim2Type = "New Claim Type";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <IdentityServerDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var roleClaim1 = new RoleClaim
{
ClaimType = "Claim 1 Type",
ClaimValue = "Claim 1 Value"
};
var roleClaim2 = new RoleClaim
{
ClaimType = originalRoleClaim2Type,
ClaimValue = "Claim 2 Value"
};
var roleClaim3 = new RoleClaim
{
ClaimType = "Claim 3 Type",
ClaimValue = "Claim 3 Value"
};
var roleClaim4 = new RoleClaim
{
ClaimType = "Claim 4 Type",
ClaimValue = "Claim 4 Value"
};
var role = new Role
{
Name = "Role Name"
};
role.RoleClaims.Add(roleClaim1);
role.RoleClaims.Add(roleClaim2);
role.RoleClaims.Add(roleClaim3);
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult post;
// Act
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
var model = new ClaimsModel(_roleManager.Object)
{
Role = role
};
model.Role.RoleClaims.Single(x => x.ClaimType.Equals(roleClaim2.ClaimType)).ClaimType = newRoleClaim2Type;
model.Role.RoleClaims.Remove(roleClaim3);
model.Role.RoleClaims.Add(roleClaim4);
post = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_roleManager.Verify(x => x.RemoveClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(roleClaim1.ClaimType) && y.Value.Equals(roleClaim1.ClaimValue))),
Times.Never);
_roleManager.Verify(x => x.AddClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(roleClaim1.ClaimType) && y.Value.Equals(roleClaim1.ClaimValue))),
Times.Never);
_roleManager.Verify(x => x.RemoveClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(originalRoleClaim2Type) && y.Value.Equals(roleClaim2.ClaimValue))),
Times.Once);
_roleManager.Verify(x => x.AddClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(newRoleClaim2Type) && y.Value.Equals(roleClaim2.ClaimValue))),
Times.Once);
_roleManager.Verify(
x => x.AddClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(roleClaim4.ClaimType) && y.Value.Equals(roleClaim4.ClaimValue))),
Times.Once);
_roleManager.Verify(
x => x.RemoveClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(roleClaim3.ClaimType) && y.Value.Equals(roleClaim3.ClaimValue))),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Role.Id), key);
Assert.Equal(role.Id, value);
});
}
public async Task OnPostAsync()
{
// Arrange
const string originalUserClaim2Type = "Claim 2 Type";
const string newUserClaim2Type = "New Claim Type";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var userClaim1 = new UserClaim
{
ClaimType = "Claim 1 Type",
ClaimValue = "Claim 1 Value"
};
var userClaim2 = new UserClaim
{
ClaimType = originalUserClaim2Type,
ClaimValue = "Claim 2 Value"
};
var userClaim3 = new UserClaim
{
ClaimType = "Claim 3 Type",
ClaimValue = "Claim 3 Value"
};
var userClaim4 = new UserClaim
{
ClaimType = "Claim 4 Type",
ClaimValue = "Claim 4 Value"
};
var user = new User
{
Email = "Email",
Claims = new List <UserClaim>
{
userClaim1,
userClaim2,
userClaim3
}
};
using (var context = new OidcDbContext(options))
{
context.Add(user);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult post;
// Act
using (var context = new OidcDbContext(options))
{
_userManager.Setup(x => x.Users).Returns(context.Users);
var model = new ClaimsModel(_userManager.Object)
{
UserModel = user
};
model.UserModel.Claims.Single(x => x.ClaimType.Equals(userClaim2.ClaimType)).ClaimType = newUserClaim2Type;
model.UserModel.Claims.Remove(userClaim3);
model.UserModel.Claims.Add(userClaim4);
post = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_userManager.Verify(x => x.ReplaceClaimAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <Claim>(y => y.Type.Equals(userClaim1.ClaimType) && y.Value.Equals(userClaim1.ClaimValue)),
It.IsAny <Claim>()),
Times.Never);
_userManager.Verify(x => x.ReplaceClaimAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <Claim>(y => y.Type.Equals(originalUserClaim2Type) && y.Value.Equals(userClaim2.ClaimValue)),
It.Is <Claim>(y => y.Type.Equals(newUserClaim2Type) && y.Value.Equals(userClaim2.ClaimValue))),
Times.Once);
_userManager.Verify(
x => x.AddClaimsAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <IEnumerable <Claim> >(y => y.SingleOrDefault(z => z.Type.Equals(userClaim4.ClaimType) && z.Value.Equals(userClaim4.ClaimValue)) != null)),
Times.Once);
_userManager.Verify(
x => x.RemoveClaimsAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <IEnumerable <Claim> >(y => y.SingleOrDefault(z => z.Type.Equals(userClaim3.ClaimType) && z.Value.Equals(userClaim3.ClaimValue)) != null)),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(User.Id), key);
Assert.Equal(user.Id, value);
});
}
public async Task OnPostAsync()
{
// Arrange
const string claim1OriginalValue = "Original Value";
const string claim1EditedValue = "Edited Value";
const string newClaimValue = "New Value";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
ClaimsModel claims;
IActionResult post;
var claim1 = new ClientClaim
{
Id = Random.Next(),
Value = claim1OriginalValue
};
var claim2 = new ClientClaim {
Id = Random.Next()
};
var client = new Client
{
Id = Random.Next(),
Claims = new List <ClientClaim>
{
claim1,
claim2
}
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
claims = new ClaimsModel(context)
{
Client = new Client
{
Id = client.Id,
Claims = new List <ClientClaim>
{
new ClientClaim
{
Id = claim1.Id,
Value = claim1EditedValue
},
new ClientClaim {
Value = newClaimValue
}
}
}
};
post = await claims.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
client = await context.Clients
.Include(x => x.Claims)
.SingleOrDefaultAsync(x => x.Id.Equals(client.Id))
.ConfigureAwait(false);
claim1 = client.Claims.SingleOrDefault(x => x.Id.Equals(claim1.Id));
claim2 = client.Claims.SingleOrDefault(x => x.Id.Equals(claim2.Id));
var newClaim = client.Claims.SingleOrDefault(x => x.Value.Equals(newClaimValue));
Assert.NotNull(claim1);
Assert.Equal(claim1EditedValue, claim1.Value);
Assert.Null(claim2);
Assert.NotNull(newClaim);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Client.Id), key);
Assert.Equal(claims.Client.Id, value);
});
}