public async void UpdateRoleAsync_Success()
{
// Arrange
var user = PrincipalHelper.CreateForRole("admin-users");
var helper = new TestHelper();
var controller = helper.CreateController <RoleController>(user);
var mapper = helper.GetService <IMapper>();
var service = helper.GetService <Mock <IPimsKeycloakService> >();
var erole = new Entity.PimsRole(Guid.NewGuid(), "test")
{
Description = "description"
};
service.Setup(m => m.UpdateRoleAsync(It.IsAny <Entity.PimsRole>())).Returns(Task.FromResult(erole));
var model = mapper.Map <Model.Update.RoleModel>(erole);
// Act
var result = await controller.UpdateRoleAsync(erole.RoleUid, model);
// Assert
var actionResult = Assert.IsType <JsonResult>(result);
var actualResult = Assert.IsType <Model.RoleModel>(actionResult.Value);
var expectedResult = mapper.Map <Model.RoleModel>(erole);
Assert.Equal(expectedResult.Id, actualResult.Id);
Assert.Equal(expectedResult.Name, actualResult.Name);
Assert.Equal(expectedResult.Description, actualResult.Description);
service.Verify(m => m.UpdateRoleAsync(It.IsAny <Entity.PimsRole>()), Times.Once());
}
public void GetRoleCodes()
{
// Arrange
var helper = new TestHelper();
var controller = helper.CreateController <LookupController>(Permissions.PropertyView);
var mapper = helper.GetService <IMapper>();
var service = helper.GetService <Mock <IPimsRepository> >();
var role = new Entity.PimsRole
{
Id = 1,
RoleUid = Guid.NewGuid(),
Name = "Ministry of Health",
Description = "The Ministry of Health"
};
service.Setup(m => m.Lookup.GetRoles()).Returns(new[] { role });
// Act
var result = controller.GetRoles();
// Assert
var actionResult = Assert.IsType <JsonResult>(result);
var actualResult = Assert.IsType <Model.RoleModel[]>(actionResult.Value);
Assert.Equal(new[] { mapper.Map <Model.RoleModel>(role) }, actualResult, new DeepPropertyCompare());
service.Verify(m => m.Lookup.GetRoles(), Times.Once());
}
public void GetRoles_Filtered_Success()
{
// Arrange
var helper = new TestHelper();
var controller = helper.CreateController <RoleController>(Permissions.AdminRoles);
var mapper = helper.GetService <IMapper>();
var service = helper.GetService <Mock <IPimsRepository> >();
var roles = new Entity.PimsRole[] { EntityHelper.CreateRole("role1"), EntityHelper.CreateRole("role2") };
var paged = new Entity.Models.Paged <Entity.PimsRole>(roles);
service.Setup(m => m.Role.Get(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>())).Returns(paged);
// Act
var result = controller.GetRoles(1, 10, "test");
// Assert
var actionResult = Assert.IsType <JsonResult>(result);
Assert.Null(actionResult.StatusCode);
var actualResult = Assert.IsType <Pims.Api.Models.PageModel <Model.RoleModel> >(actionResult.Value);
Assert.Equal(mapper.Map <Model.RoleModel[]>(roles), actualResult.Items, new DeepPropertyCompare());
service.Verify(m => m.Role.Get(1, 10, "test"), Times.Once());
}
/// <summary>
/// Create a new instance of a UserOrganization class.
/// </summary>
/// <param name="user"></param>
/// <param name="organization"></param>
/// <param name="role"></param>
public PimsUserOrganization(PimsUser user, PimsOrganization organization, PimsRole role)
{
this.User = user ?? throw new ArgumentNullException(nameof(user));
this.UserId = user.Id;
this.Organization = organization ?? throw new ArgumentNullException(nameof(organization));
this.OrganizationId = organization.Id;
this.Role = role ?? throw new ArgumentNullException(nameof(role));
this.RoleId = role.RoleId;
}
/// <summary>
/// Create a new instance of a RoleClaim class.
/// </summary>
/// <param name="role"></param>
/// <param name="claim"></param>
public PimsRoleClaim(PimsRole role, PimsClaim claim)
{
this.Role = role;
this.RoleId = role?.RoleId ??
throw new ArgumentNullException(nameof(role));
this.Claim = claim;
this.ClaimId = claim?.ClaimId ??
throw new ArgumentNullException(nameof(claim));
}
/// <summary>
/// Create a new instance of a AccessRequest class.
/// </summary>
/// <param name="user"></param>
/// <param name="role"></param>
/// <param name="status"></param>
public PimsAccessRequest(PimsUser user, PimsRole role, PimsAccessRequestStatusType status) : this()
{
this.User = user ?? throw new ArgumentNullException(nameof(user));
this.UserId = user.Id;
this.Role = role ?? throw new ArgumentNullException(nameof(role));
this.RoleId = role.RoleId;
this.AccessRequestStatusTypeCodeNavigation = status ?? throw new ArgumentNullException(nameof(status));
this.AccessRequestStatusTypeCode = status.Id;
}
/// <summary>
/// Create a new instance of a UserRole class.
/// </summary>
/// <param name="user"></param>
/// <param name="role"></param>
public PimsUserRole(PimsUser user, PimsRole role)
{
this.User = user;
this.UserId = user?.Id ??
throw new ArgumentNullException(nameof(user));
this.Role = role;
this.RoleId = role?.RoleId ??
throw new ArgumentNullException(nameof(role));
}
/// <summary>
/// Update the specified role in keycloak and PIMS.
/// This will add the role to PIMS if it does not current exist.
/// </summary>
/// <param name="role"></param>
/// <exception type="KeyNotFoundException">User does not exist in keycloak or PIMS.</exception>
/// <returns></returns>
public async Task <Entity.PimsRole> UpdateRoleAsync(Entity.PimsRole role)
{
if (await _keycloakService.GetGroupAsync(role.RoleUid) == null)
{
throw new KeyNotFoundException();
}
// Role does not exist in PIMS, it needs to be added.
if (_pimsRepository.Role.Find(role.RoleId) == null)
{
_pimsRepository.Role.Add(role);
}
else
{
_pimsRepository.Role.Update(role);
}
var kmodel = _mapper.Map <KModel.GroupModel>(role);
await _keycloakService.UpdateGroupAsync(kmodel);
return(role);
}
public async void GetRoleAsync_Success()
{
// Arrange
var user = PrincipalHelper.CreateForRole("admin-users");
var helper = new TestHelper();
var controller = helper.CreateController <RoleController>(user);
var mapper = helper.GetService <IMapper>();
var service = helper.GetService <Mock <IPimsKeycloakService> >();
var erole = new Entity.PimsRole(Guid.NewGuid(), "test");
service.Setup(m => m.GetRoleAsync(It.IsAny <Guid>())).Returns(Task.FromResult(erole));
// Act
var result = await controller.GetRoleAsync(erole.RoleUid);
// Assert
var actionResult = Assert.IsType <JsonResult>(result);
var actualResult = Assert.IsType <Model.RoleModel>(actionResult.Value);
Assert.Equal(mapper.Map <Model.RoleModel>(erole), actualResult, new DeepPropertyCompare());
service.Verify(m => m.GetRoleAsync(It.IsAny <Guid>()), Times.Once());
}
public async void GetRolesAsync_Success()
{
// Arrange
var user = PrincipalHelper.CreateForRole("admin-users");
var helper = new TestHelper();
var controller = helper.CreateController <RoleController>(user);
var mapper = helper.GetService <IMapper>();
var service = helper.GetService <Mock <IPimsKeycloakService> >();
var erole = new Entity.PimsRole(Guid.NewGuid(), "test");
var eroles = new[] { erole };
service.Setup(m => m.GetRolesAsync(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>())).Returns(Task.FromResult((IEnumerable <Entity.PimsRole>)eroles));
// Act
var result = await controller.GetRolesAsync(1, 10);
// Assert
var actionResult = Assert.IsType <JsonResult>(result);
var data = Assert.IsType <Model.RoleModel[]>(actionResult.Value);
Assert.Equal(mapper.Map <Model.RoleModel[]>(eroles), data, new DeepPropertyCompare());
service.Verify(m => m.GetRolesAsync(1, 10, It.IsAny <string>()), Times.Once());
}
/// <summary>
/// Create a new instance of an AccessRequest for a default user.
/// </summary>
/// <param name="id"></param>
/// <param name="keycloakUserId"></param>
/// <param name="username"></param>
/// <param name="firstName"></param>
/// <param name="lastName"></param>
/// <param name="person"></param>
/// <param name="role"></param>
/// <param name="organization"></param>
/// <returns></returns>
public static Entity.PimsUser CreateUser(long id, Guid keycloakUserId, string username, string firstName = "given name", string lastName = "surname", Entity.PimsRole role = null, Entity.PimsOrganization organization = null, Entity.PimsAddress address = null)
{
organization ??= EntityHelper.CreateOrganization(id, "Organization 1");
role ??= EntityHelper.CreateRole("Real Estate Manager");
var person = new Entity.PimsPerson(lastName, firstName, address);
person.PimsContactMethods = new List <Entity.PimsContactMethod>();
var user = new Entity.PimsUser(keycloakUserId, username, person)
{
Id = id,
IssueDate = DateTime.UtcNow,
ConcurrencyControlNumber = 1
};
user.PimsUserRoles.Add(new Entity.PimsUserRole()
{
Role = role, RoleId = role.Id, User = user, UserId = user.Id
});
user.PimsUserOrganizations.Add(new Entity.PimsUserOrganization()
{
Organization = organization, OrganizationId = organization.Id, User = user, UserId = user.Id
});
return(user);
}
/// <summary>
/// Create a new instance of an AccessRequest for the specified user.
/// </summary>
/// <param name="id"></param>
/// <param name="user"></param>
/// <param name="role"></param>
/// <param name="organization"></param>
/// <returns></returns>
public static Entity.PimsAccessRequest CreateAccessRequest(long id, Entity.PimsUser user, Entity.PimsRole role, Entity.PimsOrganization organization)
{
user ??= EntityHelper.CreateUser("test");
role ??= EntityHelper.CreateRole("Real Estate Manager");
var accessRequest = new Entity.PimsAccessRequest()
{
AccessRequestId = id,
UserId = user.Id,
User = user,
RoleId = role.Id,
Role = role
};
organization ??= EntityHelper.CreateOrganization(id, "test", EntityHelper.CreateOrganizationType("Type 1"), EntityHelper.CreateOrganizationIdentifierType("Identifier 1"), EntityHelper.CreateAddress(id));
accessRequest.PimsAccessRequestOrganizations.Add(new Entity.PimsAccessRequestOrganization()
{
AccessRequestId = id,
AccessRequest = accessRequest,
OrganizationId = organization.Id,
Organization = organization
});
return(accessRequest);
}
