public void Create_ShouldThrowDomainValidationException_WhenRoleLevelIsAccountAndNoAccountIdsProvided(ApplicationLevel level, string errorCode)
{
var createAppResourceCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
createAppResourceCmd.ApplicationLevel = level;
var appResource = ApplicationResource.Create(createAppResourceCmd);
var addActionCmd = ApplicationResourceCmdGenerator.AddResourceActionCommand;
var action = appResource.AddResourceAction(addActionCmd);
var roleCmdGen = new RoleCmdGenerator();
var createRoleCmd = roleCmdGen.CreateRoleCommand;
createRoleCmd.ApplicationLevel = level;
var role = Role.Create(createRoleCmd);
var updateRolePermissions = roleCmdGen.UpdateRolePermissionsCommand;
updateRolePermissions.Permissions.First().Action = action;
role.UpdatePermissions(updateRolePermissions);
var userCmdGen = new UserCmdGenerator();
var createUserCmd = userCmdGen.CreateUserCommand;
createUserCmd.UserRoles = new[] { new UserCommandRole {
Role = role
} };
var ex = Assert.Throws <DomainValidationException>(() => User.Create(createUserCmd));
Assert.Single(ex.ValidationErrors);
Assert.Equal(errorCode, ex.ValidationErrors.Single().Code);
}
public void UpdatePermissions_ShouldUpdatePermissions_WhenCommandIsValid()
{
var roleCmdGen = new RoleCmdGenerator();
var createCmd = roleCmdGen.CreateRoleCommand;
var role = Role.Create(createCmd);
var createResourceCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
var resource = ApplicationResource.Create(createResourceCmd);
var action = resource.AddResourceAction(ApplicationResourceCmdGenerator.AddResourceActionCommand);
var command = new UpdateRolePermissionsCommand
{
Permissions = new[] { new UpdateRolePermissionItem {
Action = action, Permission = Permission.Allow
} }
};
try
{
role.UpdatePermissions(command);
}
catch (DomainValidationException ex)
{
Assert.True(false, Newtonsoft.Json.JsonConvert.SerializeObject(ex.ValidationErrors));
}
Assert.Contains(role.RolePermissions,
p => p.Action == command.Permissions.Single().Action &&
p.Permission == command.Permissions.Single().Permission);
}
public void UpdatePermissions_ShouldAddRolePermissionsUpdatedEvent_WhenCommandIsValid()
{
var roleCmdGen = new RoleCmdGenerator();
var createCmd = roleCmdGen.CreateRoleCommand;
var role = Role.Create(createCmd);
var createResourceCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
var resource = ApplicationResource.Create(createResourceCmd);
var action = resource.AddResourceAction(ApplicationResourceCmdGenerator.AddResourceActionCommand);
var addPermissionCmd = roleCmdGen.UpdateRolePermissionsCommand;
addPermissionCmd.Permissions.First().Action = action;
try
{
role.UpdatePermissions(addPermissionCmd);
}
catch (DomainValidationException ex)
{
Assert.True(false, Newtonsoft.Json.JsonConvert.SerializeObject(ex.ValidationErrors));
}
Assert.Equal(2, role.Events.Count());
var addedEvent = Assert.IsType <RolePermissionsUpdatedEvent>(role.Events.Last());
Assert.Equal(role.RolePermissions.Count(), addedEvent.Permissions.Count());
Assert.All(role.RolePermissions, (item)
=> Assert.Contains(addedEvent.Permissions, evi => evi.Action.Id == item.Action.Id && evi.Permission == item.Permission));
}
public void Create_ShouldSetPropertyValuesCorrectly_WhenCommandIsValid()
{
var roleCmdGen = new RoleCmdGenerator();
var command = roleCmdGen.CreateRoleCommand;
var role = Role.Create(command);
Assert.Equal(command.Name, role.Name);
}
public void Update_ShouldThrowDomainValidationException_WhenCommandIsInvalid(UpdateRoleCommand command, ValidationError[] erros)
{
var roleCmdGen = new RoleCmdGenerator();
var createCmd = roleCmdGen.CreateRoleCommand;
var role = Role.Create(createCmd);
var ex = Assert.Throws <DomainValidationException>(() => role.Update(command));
Assert.Equal(erros.Length, ex.ValidationErrors.Count());
Assert.Contains(erros, item => ex.ValidationErrors.Any(err => err.Code == item.Code && err.Member == item.Member));
}
public void Create_ShouldAddRoleCreatedEvent_WhenCommandIsValid()
{
var roleCmdGen = new RoleCmdGenerator();
var command = roleCmdGen.CreateRoleCommand;
var role = Role.Create(command);
Assert.Single(role.Events);
Assert.Contains(role.Events, item => item is RoleCreatedEvent createdEvent &&
createdEvent.Name == command.Name);
}
public void Delete_ShouldAddRoleDeletedEvent_Called()
{
var roleCmdGen = new RoleCmdGenerator();
var createCmd = roleCmdGen.CreateRoleCommand;
var role = Role.Create(createCmd);
role.Delete();
Assert.Equal(2, role.Events.Count());
Assert.IsType <RoleDeletedEvent>(role.Events.Last());
}
public void Update_ShouldAddRoleUpdatedEvent_WhenCommandIsValid()
{
var roleCmdGen = new RoleCmdGenerator();
var createCmd = roleCmdGen.CreateRoleCommand;
var role = Role.Create(createCmd);
var updateCmd = roleCmdGen.UpdateRoleCommand;
role.Update(updateCmd);
Assert.Equal(2, role.Events.Count);
Assert.Contains(role.Events.Skip(1), item => item is RoleUpdatedEvent createdEvent &&
createdEvent.Name == updateCmd.Name);
}
public void UpdatePermissions_ShouldThrowDomainValidaitonException_WhenCommandIsInvalid(UpdateRolePermissionsCommand command, ValidationError[] errors)
{
var roleCmdGen = new RoleCmdGenerator();
var createCmd = roleCmdGen.CreateRoleCommand;
var role = Role.Create(createCmd);
var createResourceCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
var resource = ApplicationResource.Create(createResourceCmd);
var action = resource.AddResourceAction(ApplicationResourceCmdGenerator.AddResourceActionCommand);
var ex = Assert.Throws <DomainValidationException>(() => role.UpdatePermissions(command));
Assert.Equal(errors.Length, ex.ValidationErrors.Count());
Assert.All(ex.ValidationErrors, e => errors.Any(err => err.Code == e.Code && err.Member == e.Member));
}
public async Task CreateRole_ShouldReturnTheNewResourceId_WhenRequestIsValid()
{
var roleCmdGen = new RoleCmdGenerator();
var command = roleCmdGen.CreateRoleCommand;
var response = await this.client
.PostAsJsonAsync($"{RoleApiRoutes.CONTROLLER}/{RoleApiRoutes.CREATE_ROLE}", command);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var result = await response.Content.ReadAsStringAsync();
int.TryParse(result, out int id);
Assert.True(id > 0, $"Invalid id: {result}");
}
public void Create_ShouldSetAllPropertiesCorrectly_WhenCommandIsValid()
{
var roleCmdGen = new RoleCmdGenerator();
var createRoleCmd = roleCmdGen.CreateRoleCommand;
createRoleCmd.ApplicationLevel = ApplicationLevel.Organisation;
var roleOrgLevel = Role.Create(createRoleCmd);
createRoleCmd.ApplicationLevel = ApplicationLevel.Account;
var roleAccLevel = Role.Create(createRoleCmd);
var userCmdGen = new UserCmdGenerator();
var createUserCmd = userCmdGen.CreateUserCommand;
createUserCmd.UserRoles = new[] {
new UserCommandRole {
Role = roleOrgLevel, GrantedOrganisations = new[] { 1L, 2L }
},
new UserCommandRole {
Role = roleAccLevel, GrantedAccounts = new[] { 3L, 4L }
}
};
var user = User.Create(createUserCmd);
Assert.Equal(createUserCmd.Name, user.Name);
Assert.Equal(createUserCmd.Email, user.Email);
Assert.Equal(createUserCmd.Login, user.Login);
Assert.Equal(createUserCmd.Country, user.Country);
Assert.Equal(createUserCmd.Currency, user.Currency);
Assert.All(user.Roles, role
=> Assert.Contains(createUserCmd.UserRoles, cmdItem
=> role.Role.Id == cmdItem.Role.Id &&
((role.Accounts == null && cmdItem.GrantedAccounts == null) ||
role.Accounts?.SequenceEqual(cmdItem.GrantedAccounts ?? Enumerable.Empty <long>()) == true) &&
((role.Organisations == null && cmdItem.GrantedOrganisations == null) ||
role.Organisations?.SequenceEqual(cmdItem.GrantedOrganisations ?? Enumerable.Empty <long>()) == true)));
}
public async Task UpdateRole_ShouldUpdateJustProvidedPropertiesOfRole_WhenOnlySomePropertyProvided()
{
var role = this.context.Roles.First();
var roleCmdGen = new RoleCmdGenerator();
var command = roleCmdGen.UpdateRoleCommand;
var uriBuilder = new UriBuilder
{
Path = $"{RoleApiRoutes.CONTROLLER}/{RoleApiRoutes.PATCH_ROLE.Replace("{roleId}", role.Id.ToString())}",
};
using (var content = new StringContent(JsonSerializer.Serialize(new { command.ApplicationLevel }), System.Text.Encoding.UTF8, MimeTypes.Json))
{
var patchResponse = await this.client.PatchAsync(uriBuilder.Uri, content);
Assert.Equal(HttpStatusCode.NoContent, patchResponse.StatusCode);
// Detach the used entities so we can query it fresh from database.
this.context.Entry(role).State = EntityState.Detached;
var resourceAfterRequest = await this.context.Roles.FindByIdAsync(role.Id);
Assert.Equal(role.Name, resourceAfterRequest.Name);
}
}
