public async Task OnGetAsync_InvalidId()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync_InvalidId)}";
var options = new DbContextOptionsBuilder<OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var role = new Role {Id = Guid.NewGuid()};
using (var context = new OidcDbContext(options))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
UsersModel model;
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
model = new UsersModel(_roleManager.Object);
get = await model.OnGetAsync(Guid.Empty).ConfigureAwait(false);
}
// Assert
Assert.Null(model.Role);
Assert.Null(model.Users);
Assert.IsType<NotFoundResult>(get);
}
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 secrets = new SecretsModel(context)
{
Client = new Client {
Id = Random.Next()
}
};
post = await secrets.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;
SecretsModel secrets;
IActionResult post;
var client = new Client
{
Id = Random.Next(),
ClientSecrets = new List <ClientSecret>
{
new ClientSecret {
Id = Random.Next()
}
}
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
secrets = new SecretsModel(context)
{
Client = new Client {
Id = client.Id
}
};
post = await secrets.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
client = await context.Clients
.Include(x => x.ClientSecrets)
.SingleOrDefaultAsync(x => x.Id.Equals(client.Id))
.ConfigureAwait(false);
Assert.Empty(client.ClientSecrets);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Secrets", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Client.Id), key);
Assert.Equal(secrets.Client.Id, value);
});
}
public async Task OnPostAsync_AllRemoved()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_AllRemoved)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
ClaimTypesModel claims;
IActionResult post;
var apiResource = new ApiResource
{
Id = Random.Next(),
UserClaims = new List <ApiResourceClaim>
{
new ApiResourceClaim {
Id = Random.Next()
}
}
};
using (var context = new OidcDbContext(options))
{
context.Add(apiResource);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
claims = new ClaimTypesModel(context)
{
ApiResource = new ApiResource {
Id = apiResource.Id
}
};
post = await claims.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
apiResource = await context.ApiResources
.Include(x => x.UserClaims)
.SingleOrDefaultAsync(x => x.Id.Equals(apiResource.Id))
.ConfigureAwait(false);
Assert.Empty(apiResource.UserClaims);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/ClaimTypes", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(ApiResource.Id), key);
Assert.Equal(claims.ApiResource.Id, value);
});
}
public async Task OnPostAsync_AllRemoved()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_AllRemoved)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
PropertiesModel properties;
IActionResult post;
var identityResource = new IdentityResource
{
Id = Random.Next(),
Properties = new List <IdentityResourceProperty>
{
new IdentityResourceProperty {
Id = Random.Next()
}
}
};
using (var context = new OidcDbContext(options))
{
context.Add(identityResource);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
properties = new PropertiesModel(context)
{
IdentityResource = new IdentityResource {
Id = identityResource.Id
}
};
post = await properties.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
identityResource = await context.IdentityResources
.Include(x => x.Properties)
.SingleOrDefaultAsync(x => x.Id.Equals(identityResource.Id))
.ConfigureAwait(false);
Assert.Empty(identityResource.Properties);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Properties", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(IdentityResource.Id), key);
Assert.Equal(properties.IdentityResource.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 OnGetAsync()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var role = new Role
{
UserRoles = new List <UserRole>
{
new UserRole {
User = new User()
},
new UserRole {
User = new User()
},
new UserRole {
User = new User()
}
}
};
using (var context = new OidcDbContext(options))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
var usersList = await context.Users.ToListAsync().ConfigureAwait(false);
_userManager.Setup(x => x.Users).Returns(usersList.AsQueryable());
}
UsersModel model;
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
model = new UsersModel(_roleManager.Object, _userManager.Object);
get = await model.OnGetAsync(role.Id).ConfigureAwait(false);
}
// Assert
Assert.NotNull(model.Role);
Assert.Equal(role.Id, model.Role.Id);
var users = Assert.IsAssignableFrom <IEnumerable <User> >(model.Users);
Assert.Equal(role.UserRoles.Count, users.Count());
Assert.IsType <PageResult>(get);
}
public async Task OnGetAsync()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var user = new User
{
Claims = new List <UserClaim>
{
new UserClaim {
ClaimType = "Claim 1 Type"
},
new UserClaim {
ClaimType = "Claim 2 Type"
},
new UserClaim {
ClaimType = "Claim 3 Type"
}
}
};
using (var context = new OidcDbContext(options))
{
context.Add(user);
await context.SaveChangesAsync().ConfigureAwait(false);
}
ClaimsModel model;
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_userManager.Setup(x => x.Users).Returns(context.Users);
model = new ClaimsModel(_userManager.Object);
get = await model.OnGetAsync(user.Id).ConfigureAwait(false);
}
// Assert
Assert.NotNull(model.UserModel);
Assert.Equal(user.Id, model.UserModel.Id);
var claims = Assert.IsAssignableFrom <IEnumerable <UserClaim> >(model.Claims);
Assert.Equal(user.Claims.Count, claims.Count());
Assert.IsType <PageResult>(get);
}
public async Task OnGetAsync()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var role = new Role
{
Id = Guid.NewGuid(),
RoleClaims = new List <RoleClaim>
{
new RoleClaim(),
new RoleClaim(),
new RoleClaim()
}
};
using (var context = new OidcDbContext(options))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
ClaimsModel model;
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
model = new ClaimsModel(_roleManager.Object);
get = await model.OnGetAsync(role.Id).ConfigureAwait(false);
}
// Assert
Assert.NotNull(model.Role);
Assert.Equal(role.Id, model.Role.Id);
var claims = Assert.IsAssignableFrom <IEnumerable <RoleClaim> >(model.Claims);
Assert.Equal(role.RoleClaims.Count, claims.Count());
Assert.IsType <PageResult>(get);
}
public async Task OnGetAsync()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var identityResource = new IdentityResource
{
Id = Random.Next(),
Properties = new List <IdentityResourceProperty>
{
new IdentityResourceProperty(),
new IdentityResourceProperty(),
new IdentityResourceProperty()
}
};
PropertiesModel model;
IActionResult get;
using (var context = new OidcDbContext(options))
{
context.Add(identityResource);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
model = new PropertiesModel(context);
get = await model.OnGetAsync(identityResource.Id).ConfigureAwait(false);
}
// Assert
Assert.NotNull(model.IdentityResource);
Assert.Equal(identityResource.Id, model.IdentityResource.Id);
var properties = Assert.IsAssignableFrom <IEnumerable <IdentityResourceProperty> >(model.Properties);
Assert.Equal(identityResource.Properties.Count, properties.Count());
Assert.IsType <PageResult>(get);
}
public async Task OnGetAsync()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var client = new Client
{
Id = Random.Next(),
Claims = new List <ClientClaim>
{
new ClientClaim(),
new ClientClaim(),
new ClientClaim()
}
};
ClaimsModel model;
IActionResult get;
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
model = new ClaimsModel(context);
get = await model.OnGetAsync(client.Id).ConfigureAwait(false);
}
// Assert
Assert.NotNull(model.Client);
Assert.Equal(client.Id, model.Client.Id);
var claims = Assert.IsAssignableFrom <IEnumerable <ClientClaim> >(model.Claims);
Assert.Equal(client.Claims.Count, claims.Count());
Assert.IsType <PageResult>(get);
}
public async Task OnGetAsync()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var apiResource = new ApiResource
{
Id = Random.Next(),
Secrets = new List <ApiSecret>
{
new ApiSecret(),
new ApiSecret(),
new ApiSecret()
}
};
SecretsModel model;
IActionResult get;
using (var context = new OidcDbContext(options))
{
context.Add(apiResource);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
model = new SecretsModel(context);
get = await model.OnGetAsync(apiResource.Id).ConfigureAwait(false);
}
// Assert
Assert.NotNull(model.ApiResource);
Assert.Equal(apiResource.Id, model.ApiResource.Id);
var secrets = Assert.IsAssignableFrom <IEnumerable <ApiSecret> >(model.Secrets);
Assert.Equal(apiResource.Secrets.Count, secrets.Count());
Assert.IsType <PageResult>(get);
}
public async Task OnGetAsync_InvalidModel()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync_InvalidModel)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
ClaimsModel model;
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
model = new ClaimsModel(context);
get = await model.OnGetAsync(Random.Next()).ConfigureAwait(false);
}
// Assert
Assert.Null(model.Client);
Assert.Null(model.Claims);
Assert.IsType <NotFoundResult>(get);
}
public async Task OnGetAsync_InvalidId()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync_InvalidId)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var user = new User
{
Claims = new List <UserClaim>
{
new UserClaim(),
new UserClaim(),
new UserClaim()
}
};
using (var context = new OidcDbContext(options))
{
context.Add(user);
await context.SaveChangesAsync().ConfigureAwait(false);
}
ClaimsModel model;
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_userManager.Setup(x => x.Users).Returns(context.Users);
model = new ClaimsModel(_userManager.Object);
get = await model.OnGetAsync(Guid.Empty).ConfigureAwait(false);
}
// Assert
Assert.Null(model.UserModel);
Assert.Null(model.Claims);
Assert.IsType <NotFoundResult>(get);
}
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_AllRemoved()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_AllRemoved)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var role = new Role
{
Name = "Role Name",
UserRoles = new List <UserRole>
{
new UserRole {
User = new User()
}
}
};
using (var context = new OidcDbContext(options))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
var usersList = await context.Users.ToListAsync().ConfigureAwait(false);
_userManager.Setup(x => x.Users).Returns(usersList.AsQueryable());
_userManager.Setup(x => x.GetUsersInRoleAsync(role.Name)).ReturnsAsync(usersList);
}
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
var model = new UsersModel(_roleManager.Object, _userManager.Object)
{
Role = new Role {
Id = role.Id
}
};
get = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
foreach (var user in _userManager.Object.Users)
{
_userManager.Verify(
x => x.RemoveClaimAsync(
user,
It.Is <Claim>(y => y.Type.Equals(ClaimTypes.Role) && y.Value.Equals(role.Name))),
Times.Once);
}
_roleManager.Verify(
x => x.UpdateAsync(It.Is <Role>(y => y.Id.Equals(role.Id) && y.UserRoles.Count == 0)),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(get);
Assert.Equal("../Details/Users", 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 scope1OriginalName = "Original Name";
const string scope1EditedName = "Edited Name";
const string newScopeName = "New Name";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
ScopesModel scopes;
IActionResult post;
var scope1 = new ApiScope
{
Id = Random.Next(),
Name = scope1OriginalName
};
var scope2 = new ApiScope {
Id = Random.Next()
};
var client = new ApiResource
{
Id = Random.Next(),
Scopes = new List <ApiScope>
{
scope1,
scope2
}
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
scopes = new ScopesModel(context)
{
ApiResource = new ApiResource
{
Id = client.Id,
Scopes = new List <ApiScope>
{
new ApiScope
{
Id = scope1.Id,
Name = scope1EditedName
},
new ApiScope {
Name = newScopeName
}
}
}
};
post = await scopes.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
client = await context.ApiResources
.Include(x => x.Scopes)
.SingleOrDefaultAsync(x => x.Id.Equals(client.Id))
.ConfigureAwait(false);
scope1 = client.Scopes.SingleOrDefault(x => x.Id.Equals(scope1.Id));
scope2 = client.Scopes.SingleOrDefault(x => x.Id.Equals(scope2.Id));
var newScope = client.Scopes.SingleOrDefault(x => x.Name.Equals(newScopeName));
Assert.NotNull(scope1);
Assert.Equal(scope1EditedName, scope1.Name);
Assert.Null(scope2);
Assert.NotNull(newScope);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Scopes", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(ApiResource.Id), key);
Assert.Equal(scopes.ApiResource.Id, value);
});
}
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 <OidcDbContext>()
.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",
RoleClaims = new List <RoleClaim>
{
roleClaim1,
roleClaim2,
roleClaim3
}
};
using (var context = new OidcDbContext(options))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult post;
// Act
using (var context = new OidcDbContext(options))
{
_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 idPRestriction1OriginalProvider = "Original Provider";
const string idPRestriction1EditedProvider = "Edited Provider";
const string newIdPRestrictionProvider = "New Provider";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
IdPRestrictionsModel idPRestrictions;
IActionResult post;
var idPRestriction1 = new ClientIdPRestriction
{
Id = Random.Next(),
Provider = idPRestriction1OriginalProvider
};
var idPRestriction2 = new ClientIdPRestriction {
Id = Random.Next()
};
var client = new Client
{
Id = Random.Next(),
IdentityProviderRestrictions = new List <ClientIdPRestriction>
{
idPRestriction1,
idPRestriction2
}
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
idPRestrictions = new IdPRestrictionsModel(context)
{
Client = new Client
{
Id = client.Id,
IdentityProviderRestrictions = new List <ClientIdPRestriction>
{
new ClientIdPRestriction
{
Id = idPRestriction1.Id,
Provider = idPRestriction1EditedProvider
},
new ClientIdPRestriction {
Provider = newIdPRestrictionProvider
}
}
}
};
post = await idPRestrictions.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
client = await context.Clients
.Include(x => x.IdentityProviderRestrictions)
.SingleOrDefaultAsync(x => x.Id.Equals(client.Id))
.ConfigureAwait(false);
idPRestriction1 = client.IdentityProviderRestrictions.SingleOrDefault(x => x.Id.Equals(idPRestriction1.Id));
idPRestriction2 = client.IdentityProviderRestrictions.SingleOrDefault(x => x.Id.Equals(idPRestriction2.Id));
var newIdPRestriction = client.IdentityProviderRestrictions.SingleOrDefault(x => x.Provider.Equals(newIdPRestrictionProvider));
Assert.NotNull(idPRestriction1);
Assert.Equal(idPRestriction1EditedProvider, idPRestriction1.Provider);
Assert.Null(idPRestriction2);
Assert.NotNull(newIdPRestriction);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/IdPRestrictions", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Client.Id), key);
Assert.Equal(idPRestrictions.Client.Id, value);
});
}
public async Task OnPostAsync()
{
// Arrange
const string secret1OriginalValue = "Original Value";
const string secret1EditedValue = "Edited Value";
const string newSecretValue = "New Value";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
SecretsModel secrets;
IActionResult post;
var secret1 = new ClientSecret
{
Id = Random.Next(),
Value = secret1OriginalValue
};
var secret2 = new ClientSecret {
Id = Random.Next()
};
var client = new Client
{
Id = Random.Next(),
ClientSecrets = new List <ClientSecret>
{
secret1,
secret2
}
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
secrets = new SecretsModel(context)
{
Client = new Client
{
Id = client.Id,
ClientSecrets = new List <ClientSecret>
{
new ClientSecret
{
Id = secret1.Id,
Value = secret1EditedValue
},
new ClientSecret {
Value = newSecretValue
}
}
}
};
post = await secrets.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
client = await context.Clients
.Include(x => x.ClientSecrets)
.SingleOrDefaultAsync(x => x.Id.Equals(client.Id))
.ConfigureAwait(false);
secret1 = client.ClientSecrets.SingleOrDefault(x => x.Id.Equals(secret1.Id));
secret2 = client.ClientSecrets.SingleOrDefault(x => x.Id.Equals(secret2.Id));
var newSecret = client.ClientSecrets.SingleOrDefault(x => x.Value.Equals(newSecretValue));
Assert.NotNull(secret1);
Assert.Equal(secret1EditedValue, secret1.Value);
Assert.Null(secret2);
Assert.NotNull(newSecret);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Secrets", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Client.Id), key);
Assert.Equal(secrets.Client.Id, value);
});
}
public async Task OnPostAsync()
{
// Arrange
const string corsOrigin1OriginalOrigin = "Original Origin";
const string corsOrigin1EditedOrigin = "Edited Origin";
const string newCorsOriginOrigin = "New Origin";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
CorsOriginsModel corsOrigins;
IActionResult post;
var corsOrigin1 = new ClientCorsOrigin
{
Id = Random.Next(),
Origin = corsOrigin1OriginalOrigin
};
var corsOrigin2 = new ClientCorsOrigin {
Id = Random.Next()
};
var client = new Client
{
Id = Random.Next(),
AllowedCorsOrigins = new List <ClientCorsOrigin>
{
corsOrigin1,
corsOrigin2
}
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
corsOrigins = new CorsOriginsModel(context)
{
Client = new Client
{
Id = client.Id,
AllowedCorsOrigins = new List <ClientCorsOrigin>
{
new ClientCorsOrigin
{
Id = corsOrigin1.Id,
Origin = corsOrigin1EditedOrigin
},
new ClientCorsOrigin {
Origin = newCorsOriginOrigin
}
}
}
};
post = await corsOrigins.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
client = await context.Clients
.Include(x => x.AllowedCorsOrigins)
.SingleOrDefaultAsync(x => x.Id.Equals(client.Id))
.ConfigureAwait(false);
corsOrigin1 = client.AllowedCorsOrigins.SingleOrDefault(x => x.Id.Equals(corsOrigin1.Id));
corsOrigin2 = client.AllowedCorsOrigins.SingleOrDefault(x => x.Id.Equals(corsOrigin2.Id));
var newCorsOrigin = client.AllowedCorsOrigins.SingleOrDefault(x => x.Origin.Equals(newCorsOriginOrigin));
Assert.NotNull(corsOrigin1);
Assert.Equal(corsOrigin1EditedOrigin, corsOrigin1.Origin);
Assert.Null(corsOrigin2);
Assert.NotNull(newCorsOrigin);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/CorsOrigins", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Client.Id), key);
Assert.Equal(corsOrigins.Client.Id, value);
});
}
public async Task OnPostAsync()
{
// Arrange
const string grantType1OriginalGrantType = "Original GrantType";
const string grantType1EditedGrantType = "Edited GrantType";
const string newGrantTypeGrantType = "New GrantType";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
GrantTypesModel grantTypes;
IActionResult post;
var grantType1 = new ClientGrantType
{
Id = Random.Next(),
GrantType = grantType1OriginalGrantType
};
var grantType2 = new ClientGrantType {
Id = Random.Next()
};
var client = new Client
{
Id = Random.Next(),
AllowedGrantTypes = new List <ClientGrantType>
{
grantType1,
grantType2
}
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
grantTypes = new GrantTypesModel(context)
{
Client = new Client
{
Id = client.Id,
AllowedGrantTypes = new List <ClientGrantType>
{
new ClientGrantType
{
Id = grantType1.Id,
GrantType = grantType1EditedGrantType
},
new ClientGrantType {
GrantType = newGrantTypeGrantType
}
}
}
};
post = await grantTypes.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
client = await context.Clients
.Include(x => x.AllowedGrantTypes)
.SingleOrDefaultAsync(x => x.Id.Equals(client.Id))
.ConfigureAwait(false);
grantType1 = client.AllowedGrantTypes.SingleOrDefault(x => x.Id.Equals(grantType1.Id));
grantType2 = client.AllowedGrantTypes.SingleOrDefault(x => x.Id.Equals(grantType2.Id));
var newGrantType = client.AllowedGrantTypes.SingleOrDefault(x => x.GrantType.Equals(newGrantTypeGrantType));
Assert.NotNull(grantType1);
Assert.Equal(grantType1EditedGrantType, grantType1.GrantType);
Assert.Null(grantType2);
Assert.NotNull(newGrantType);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/GrantTypes", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Client.Id), key);
Assert.Equal(grantTypes.Client.Id, value);
});
}
public async Task OnPostAsync()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var user1 = new User();
var user2 = new User();
var userRole = new UserRole {
User = user1
};
var role = new Role
{
Name = "Role Name",
UserRoles = new List <UserRole>
{
userRole
}
};
using (var context = new OidcDbContext(options))
{
context.Add(role);
context.Add(user2);
await context.SaveChangesAsync().ConfigureAwait(false);
var usersList = await context.Users.ToListAsync().ConfigureAwait(false);
_userManager.Setup(x => x.Users).Returns(usersList.AsQueryable());
foreach (var user in context.Users)
{
_userManager.Setup(x => x.FindByIdAsync($"{user.Id}")).ReturnsAsync(user);
}
}
IActionResult post;
// Act
using (var context = new OidcDbContext(options))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
var model = new UsersModel(_roleManager.Object, _userManager.Object)
{
Role = role
};
model.Role.UserRoles.Remove(userRole);
model.Role.UserRoles.Add(new UserRole {
UserId = user2.Id
});
post = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_userManager.Verify(
x => x.AddClaimAsync(
user2,
It.Is <Claim>(y => y.Type.Equals(ClaimTypes.Role) && y.Value.Equals(role.Name))),
Times.Once);
_userManager.Verify(
x => x.RemoveClaimAsync(
user1,
It.Is <Claim>(y => y.Type.Equals(ClaimTypes.Role) && y.Value.Equals(role.Name))),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Users", 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 property1OriginalValue = "Original Value";
const string property1EditedValue = "Edited Value";
const string newPropertyValue = "New Value";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
PropertiesModel properties;
IActionResult post;
var property1 = new IdentityResourceProperty
{
Id = Random.Next(),
Value = property1OriginalValue
};
var property2 = new IdentityResourceProperty {
Id = Random.Next()
};
var identityResource = new IdentityResource
{
Id = Random.Next(),
Properties = new List <IdentityResourceProperty>
{
property1,
property2
}
};
using (var context = new OidcDbContext(options))
{
context.Add(identityResource);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
properties = new PropertiesModel(context)
{
IdentityResource = new IdentityResource
{
Id = identityResource.Id,
Properties = new List <IdentityResourceProperty>
{
new IdentityResourceProperty
{
Id = property1.Id,
Value = property1EditedValue
},
new IdentityResourceProperty {
Value = newPropertyValue
}
}
}
};
post = await properties.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
identityResource = await context.IdentityResources
.Include(x => x.Properties)
.SingleOrDefaultAsync(x => x.Id.Equals(identityResource.Id))
.ConfigureAwait(false);
property1 = identityResource.Properties.SingleOrDefault(x => x.Id.Equals(property1.Id));
property2 = identityResource.Properties.SingleOrDefault(x => x.Id.Equals(property2.Id));
var newProperty = identityResource.Properties.SingleOrDefault(x => x.Value.Equals(newPropertyValue));
Assert.NotNull(property1);
Assert.Equal(property1EditedValue, property1.Value);
Assert.Null(property2);
Assert.NotNull(newProperty);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Properties", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(IdentityResource.Id), key);
Assert.Equal(properties.IdentityResource.Id, value);
});
}
public async Task OnPostAsync()
{
// Arrange
const string claim1OriginalType = "Original Type";
const string claim1EditedType = "Edited Type";
const string newClaimType = "New Type";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
ClaimTypesModel claims;
IActionResult post;
var claim1 = new ApiResourceClaim
{
Id = Random.Next(),
Type = claim1OriginalType
};
var claim2 = new ApiResourceClaim {
Id = Random.Next()
};
var apiResource = new ApiResource
{
Id = Random.Next(),
UserClaims = new List <ApiResourceClaim>
{
claim1,
claim2
}
};
using (var context = new OidcDbContext(options))
{
context.Add(apiResource);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
claims = new ClaimTypesModel(context)
{
ApiResource = new ApiResource
{
Id = apiResource.Id,
UserClaims = new List <ApiResourceClaim>
{
new ApiResourceClaim
{
Id = claim1.Id,
Type = claim1EditedType
},
new ApiResourceClaim {
Type = newClaimType
}
}
}
};
post = await claims.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
apiResource = await context.ApiResources
.Include(x => x.UserClaims)
.SingleOrDefaultAsync(x => x.Id.Equals(apiResource.Id))
.ConfigureAwait(false);
claim1 = apiResource.UserClaims.SingleOrDefault(x => x.Id.Equals(claim1.Id));
claim2 = apiResource.UserClaims.SingleOrDefault(x => x.Id.Equals(claim2.Id));
var newClaim = apiResource.UserClaims.SingleOrDefault(x => x.Type.Equals(newClaimType));
Assert.NotNull(claim1);
Assert.Equal(claim1EditedType, claim1.Type);
Assert.Null(claim2);
Assert.NotNull(newClaim);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/ClaimTypes", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(ApiResource.Id), key);
Assert.Equal(claims.ApiResource.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 postLogoutRedirectUri1OriginalRedirectUri = "Original PostLogoutRedirectUri";
const string postLogoutRedirectUri1EditedRedirectUri = "Edited PostLogoutRedirectUri";
const string newPostLogoutRedirectUriRedirectUri = "New PostLogoutRedirectUri";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
PostLogoutRedirectUrisModel postLogoutRedirectUris;
IActionResult post;
var postLogoutRedirectUri1 = new ClientPostLogoutRedirectUri
{
Id = Random.Next(),
PostLogoutRedirectUri = postLogoutRedirectUri1OriginalRedirectUri
};
var postLogoutRedirectUri2 = new ClientPostLogoutRedirectUri {
Id = Random.Next()
};
var client = new Client
{
Id = Random.Next(),
PostLogoutRedirectUris = new List <ClientPostLogoutRedirectUri>
{
postLogoutRedirectUri1,
postLogoutRedirectUri2
}
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
postLogoutRedirectUris = new PostLogoutRedirectUrisModel(context)
{
Client = new Client
{
Id = client.Id,
PostLogoutRedirectUris = new List <ClientPostLogoutRedirectUri>
{
new ClientPostLogoutRedirectUri
{
Id = postLogoutRedirectUri1.Id,
PostLogoutRedirectUri = postLogoutRedirectUri1EditedRedirectUri
},
new ClientPostLogoutRedirectUri {
PostLogoutRedirectUri = newPostLogoutRedirectUriRedirectUri
}
}
}
};
post = await postLogoutRedirectUris.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
client = await context.Clients
.Include(x => x.PostLogoutRedirectUris)
.SingleOrDefaultAsync(x => x.Id.Equals(client.Id))
.ConfigureAwait(false);
postLogoutRedirectUri1 = client.PostLogoutRedirectUris.SingleOrDefault(x => x.Id.Equals(postLogoutRedirectUri1.Id));
postLogoutRedirectUri2 = client.PostLogoutRedirectUris.SingleOrDefault(x => x.Id.Equals(postLogoutRedirectUri2.Id));
var newPostLogoutRedirectUri = client.PostLogoutRedirectUris.SingleOrDefault(x => x.PostLogoutRedirectUri.Equals(newPostLogoutRedirectUriRedirectUri));
Assert.NotNull(postLogoutRedirectUri1);
Assert.Equal(postLogoutRedirectUri1EditedRedirectUri, postLogoutRedirectUri1.PostLogoutRedirectUri);
Assert.Null(postLogoutRedirectUri2);
Assert.NotNull(newPostLogoutRedirectUri);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/PostLogoutRedirectUris", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Client.Id), key);
Assert.Equal(postLogoutRedirectUris.Client.Id, value);
});
}
