public void Role_Should_Be_Created_By_RoleModel()
{
var roleModel = RoleTestData.GetUpdateUserRoleModel();
var role = roleBuilder.Build(roleModel);
Assert.AreEqual(role.Name, roleModel.Name);
Assert.AreEqual(role.Code, roleModel.Code);
Assert.AreEqual(role.Id, 0);
}
public void RoleModel_Should_Be_Created_By_Role()
{
var role = RoleTestData.GetAdminRole();
var roleModel = roleBuilder.BuildModel(role);
Assert.AreEqual(role.Name, roleModel.Name);
Assert.AreEqual(role.Code, roleModel.Code);
Assert.AreEqual(role.Id, roleModel.Id);
}
public void Role_Create_Check_Should_Fail_If_Role_Name_Already_Exist()
{
var roleModel = RoleTestData.GetUserRoleModel();
var role = RoleTestData.GetUserRole();
roleRepository.Setup(r => r.GetById(It.Is <Expression <Func <Data.Role, bool> > >(e => AreEqual(e, "roleModel.Name")))).Returns(role);
roleBusinessRules.CreateCheck(roleModel, roleRepository.Object);
roleRepository.Verify(r => r.GetById(It.IsAny <Expression <Func <Data.Role, bool> > >()), Times.Once);
}
public void Role_Should_Be_Updated_By_RoleModel()
{
var role = RoleTestData.GetUserRole();
var roleModel = RoleTestData.GetUpdateUserRoleModel();
roleAdapter.Update(role, roleModel);
Assert.AreEqual(role.Name, roleModel.Name);
Assert.AreEqual(role.Code, roleModel.Code);
}
public void Role_Create_Check_Should_Succeed()
{
var roleModel = RoleTestData.GetUserRoleModel();
var role = RoleTestData.GetNullRole();
roleRepository.Setup(r => r.GetById(a => a.Name == roleModel.Name)).Returns(role);
roleRepository.Setup(r => r.GetById(a => a.Code == roleModel.Code)).Returns(role);
roleBusinessRules.CreateCheck(roleModel, roleRepository.Object);
}
public void Role_Update_Check_Should_Throw_Exception_Role_Code_Already_Exists()
{
var roleModel = RoleTestData.GetUserRoleModel();
var role = RoleTestData.GetUserRole();
roleRepository.Setup(r => r.GetById(It.Is <Expression <Func <Data.Role, bool> > >(e => AreEqual <Data.Role, bool>(e, "roleModel.Id")))).Returns(role);
roleRepository.Setup(r => r.GetById(It.Is <Expression <Func <Data.Role, bool> > >(e => AreEqual <Data.Role, bool>(e, "roleModel.Code")))).Returns(role);
roleRepository.Setup(r => r.GetById(It.Is <Expression <Func <Data.Role, bool> > >(e => AreEqual <Data.Role, bool>(e, "roleModel.Name")))).Returns(RoleTestData.GetNullRole());
roleBusinessRules.UpdateCheck(roleModel, roleRepository.Object);
}
public void Role_Add_Existing_Code_Role_Should_Throw_Exception()
{
using (var context = new PayrollContext(IntergrationTestsSetup.ContextOptions))
{
var unitOfWork = new UnitOfWork(context);
var role = RoleTestData.GetSuperAdminRole();
unitOfWork.Role.Insert(role);
unitOfWork.Save();
}
}
public void Role_Add_Empty_Role_Should_Throw_Exception()
{
using (var context = new PayrollContext(IntergrationTestsSetup.ContextOptions))
{
var unitOfWork = new UnitOfWork(context);
var role = RoleTestData.GetEmptyRole();
unitOfWork.Role.Insert(null);
unitOfWork.Save();
}
}
public void Should_GetRoles_Empty_Roles_When_Repo_Is_Empty()
{
// Arrange
unitOfWork.Setup(x => x.Role.Get(It.IsAny <SearchFilter>())).Returns(RoleTestData.GetNullRoleResult());
// Act
var result = roleService.Get(It.IsAny <SearchFilter>());
// Assert
unitOfWork.Verify(x => x.Role.Get(It.IsAny <SearchFilter>()), Times.Once);
roleBuilder.Verify(x => x.BuildModel(It.IsAny <Data.Role>()), Times.Never);
}
public void Role_Add_Unique_Role_Should_Succeed()
{
using (var context = new PayrollContext(IntergrationTestsSetup.ContextOptions))
{
var unitOfWork = new UnitOfWork(context);
var role = RoleTestData.GetUserRole();
unitOfWork.Role.Insert(role);
unitOfWork.Save();
Assert.IsTrue(role.Id > 0);
}
}
public void Role_Update_Existing_With_Existing_Code_Role_Should_Throw_Exception()
{
using (var context = new PayrollContext(IntergrationTestsSetup.ContextOptions))
{
var unitOfWork = new UnitOfWork(context);
var role = RoleTestData.GetAdminRole();
role.Code = "Super_Admin";
unitOfWork.Role.Update(role);
unitOfWork.Save();
}
}
public void Role_Delete_Existing_Role_Should_Succeed()
{
using (var context = new PayrollContext(IntergrationTestsSetup.ContextOptions))
{
var unitOfWork = new UnitOfWork(context);
var role = RoleTestData.GetAdminRole();
var roleCount = unitOfWork.Role.CountEntities();
unitOfWork.Role.Delete(role);
unitOfWork.Save();
Assert.IsTrue(roleCount - 1 == unitOfWork.Role.CountEntities());
}
}
public void Should_Fail_To_Create_Role_When_SaveCheck_Throws_Excpetion()
{
// Arrange
roleBusinessRules.Setup(x => x.CreateCheck(It.IsAny <RoleModel>(), It.IsAny <RoleRepository>())).Throws(new ResponseValidationException(ResponseMessage.ToError("Role Create throws exception.")));
// Act
var result = roleService.Create(RoleTestData.GetUserRoleModel());
// Assert
roleBusinessRules.Verify(x => x.CreateCheck(It.IsAny <RoleModel>(), It.IsAny <RoleRepository>()), Times.Once);
roleBuilder.Verify(x => x.Build(It.IsAny <RoleModel>()), Times.Never);
roleBuilder.Verify(x => x.BuildModel(It.IsAny <Data.Role>()), Times.Never);
unitOfWork.Verify(x => x.Save(), Times.Never);
unitOfWork.Verify(x => x.Role.Insert(It.IsAny <Data.Role>()), Times.Never);
unitOfWork.Verify(x => x.Role.GetById(It.IsAny <Expression <Func <Data.Role, bool> > >()), Times.Never);
}
public void Role_Update_Existing_Role_Should_Succeed()
{
using (var context = new PayrollContext(IntergrationTestsSetup.ContextOptions))
{
var unitOfWork = new UnitOfWork(context);
var role = RoleTestData.GetAdminRole();
role.Name = "Admin User";
unitOfWork.Role.Update(role);
unitOfWork.Save();
Assert.IsTrue(role.Id == 2);
Assert.IsTrue(role.Name.Equals("Admin User"));
}
}
public static void Initialize(TestContext testContext)
{
IntergrationTestsSetup dbSetup = new IntergrationTestsSetup();
using (var context = new PayrollContext(dbSetup.ContextOptions))
{
context.Country.AddRange(CountryTestData.InitialCountries());
context.Province.AddRange(ProvinceTestData.InitialProvinces());
context.Role.AddRange(RoleTestData.InitialRoles());
context.Address.AddRange(AddressTestData.InitialAddresses());
context.Organisation.AddRange(OrganisationTestData.InitialOrganisations());
context.Account.AddRange(AccountTestData.InitialAccounts());
context.SaveChanges();
}
}
public void Should_Create_Role()
{
// Arrange
unitOfWork.Setup(x => x.Save()).Verifiable();
unitOfWork.Setup(x => x.Role.Insert(It.IsAny <Data.Role>())).Verifiable();
roleBusinessRules.Setup(x => x.CreateCheck(It.IsAny <RoleModel>(), It.IsAny <RoleRepository>())).Verifiable();
roleBuilder.Setup(x => x.Build(It.IsAny <RoleModel>())).Returns(RoleTestData.GetEmptyRole());
roleBuilder.Setup(x => x.BuildModel(It.IsAny <Data.Role>())).Returns(new RoleModel());
unitOfWork.Setup(x => x.Role.GetById(It.IsAny <Expression <Func <Data.Role, bool> > >())).Returns(RoleTestData.GetUserRole());
// Act
var result = roleService.Create(RoleTestData.GetUserRoleModel());
// Assert
roleBusinessRules.Verify(x => x.CreateCheck(It.IsAny <RoleModel>(), It.IsAny <RoleRepository>()), Times.Once);
roleBuilder.Verify(x => x.Build(It.IsAny <RoleModel>()), Times.Once);
unitOfWork.Verify(x => x.Role.GetById(It.IsAny <Expression <Func <Data.Role, bool> > >()), Times.Once);
roleBuilder.Verify(x => x.BuildModel(It.IsAny <Data.Role>()), Times.Once);
}
public void Role_Update_Should_Throw_Exception_When_Role_Null()
{
var roleModel = RoleTestData.GetUpdateUserRoleModel();
roleAdapter.Update(null, roleModel);
}
public void Role_Update_Should_Throw_Exception_When_RoleModel_Null()
{
var role = RoleTestData.GetUserRole();
roleAdapter.Update(role, null);
}
