public void TestAddPermissionThrowsExceptionIfCurrentUserDoesNotHaveRights1()
{
try
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeRoles(5, RoleRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
ControllerRecordFakes.FakePermissions(1, PermissionRepository);
UserService.Expect(a => a.CanUserManageGivenLogin("Name3", "UserName", "LoginId3")).Return(false).Repeat.Any();
PermissionRepository.Expect(a => a.EnsurePersistent(Arg <Permission> .Is.Anything)).Repeat.Any();
#endregion Arrange
#region Act
Controller.AddPermission("Name3", "LoginId3", 3);
#endregion Act
}
catch (Exception ex)
{
#region Assert
Assert.IsNotNull(ex);
Assert.AreEqual("UserName does not have access to manage LoginId3 within the Name3 application", ex.Message);
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name3", "UserName", "LoginId3"));
PermissionRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <Permission> .Is.Anything));
#endregion Assert
throw;
}
}
public void TestGetByApplication1()
{
#region Arrange
UserService = new UserService(UnitService, UnitAssociationRepository, PermissionRepository);
ControllerRecordFakes.FakeUnits(6, UnitRepository);
ControllerRecordFakes.FakeRoles(6, RoleRepository);
UnitService.Expect(a => a.GetVisibleByUser("Name1", "UserName")).Return(UnitRepository.Queryable.Where(a => a.Id == 2 || a.Id == 4)).Repeat.Any();
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
var users = new List <User>();
for (int i = 0; i < 5; i++)
{
users.Add(CreateValidEntities.User(i + 1));
users[i].UnitAssociations.Add(CreateValidEntities.UnitAssociation(i + 1));
users[i].UnitAssociations[0].Unit = UnitRepository.GetNullableById(i + 1);
}
ControllerRecordFakes.FakeUsers(0, UserRepository, users);
var permissions = new List <Permission>();
for (int i = 0; i < 5; i++)
{
permissions.Add(CreateValidEntities.Permission(i + 1));
permissions[i].User = UserRepository.GetNullableById(i + 1);
permissions[i].Application = ApplicationRepository.Queryable.First();
permissions[i].Role = RoleRepository.GetNullableById(i + 1);
}
ControllerRecordFakes.FakePermissions(0, PermissionRepository, permissions);
var unitAssociations = new List <UnitAssociation>();
for (int i = 0; i < 5; i++)
{
unitAssociations.Add(CreateValidEntities.UnitAssociation(i + 1));
unitAssociations[i].User = UserRepository.GetNullableById(i + 1);
unitAssociations[i].Application = ApplicationRepository.Queryable.First();
unitAssociations[i].Unit = UnitRepository.GetNullableById(i + 1);
}
ControllerRecordFakes.FakeUnitAssociations(0, UnitAssociationRepository, unitAssociations);
#endregion Arrange
#region Act
var result = UserService.GetByApplication("Name1", "UserName");
//var allowedUnitIds = UnitService.GetVisibleByUser("Name1", "UserName").ToList().Select(x => x.Id).ToList();
////Get everyone with perms, possibly filtered by role and unit
//var usersWithPermissions = from p in PermissionRepository.Queryable
// join u in UnitAssociationRepository.Queryable on
// new { User = p.User.Id, App = p.Application.Id }
// equals new { User = u.User.Id, App = u.Application.Id }
// where p.Application.Name == "Name1"
// where p.User.UnitAssociations.Any(a => allowedUnitIds.Contains(a.Unit.Id))
// select new { Permissions = p, UnitAssociations = u };
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count());
Assert.AreEqual("LoginId2", result.ElementAt(0).LoginId);
Assert.AreEqual("LoginId4", result.ElementAt(1).LoginId);
#endregion Assert
}
public void TestAddPermission()
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeRoles(5, RoleRepository);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
ControllerRecordFakes.FakePermissions(1, PermissionRepository);
UserService.Expect(a => a.CanUserManageGivenLogin("Name3", "UserName", "LoginId3")).Return(true).Repeat.Any();
RoleService.Expect(a => a.GetVisibleByUser("Name3", "UserName")).Return(RoleRepository.Queryable).Repeat.Any();
PermissionRepository.Expect(a => a.EnsurePersistent(Arg <Permission> .Is.Anything)).Repeat.Any();
#endregion Arrange
#region Act
Controller.AddPermission("Name3", "LoginId3", 2);
#endregion Act
#region Assert
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name3", "UserName", "LoginId3"));
RoleService.AssertWasCalled(a => a.GetVisibleByUser("Name3", "UserName"));
PermissionRepository.AssertWasCalled(a => a.EnsurePersistent(Arg <Permission> .Is.Anything));
var args = (Permission)PermissionRepository.GetArgumentsForCallsMadeOn(a => a.EnsurePersistent(Arg <Permission> .Is.Anything))[0][0];
Assert.IsNotNull(args);
Assert.AreEqual("Name2", args.Role.Name);
Assert.AreEqual("LoginId3", args.User.LoginId);
Assert.AreEqual("Name3", args.Application.ToString());
Assert.IsFalse(args.Inactive);
#endregion Assert
}
public void TestAddUnitThrowsExceptionIfCurrentUserDoesNotHaveRights2()
{
try
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUnits(5, UnitRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
ControllerRecordFakes.FakeUnitAssociations(1, UnitAssociationRepository);
UnitService.Expect(a => a.GetVisibleByUser("Name2", "UserName")).Return(UnitRepository.Queryable.Where(a => a.Id >= 4)).Repeat.Any();
UserService.Expect(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1")).Return(true).Repeat.Any();
UnitAssociationRepository.Expect(a => a.EnsurePersistent(Arg <UnitAssociation> .Is.Anything)).Repeat.Any();
#endregion Arrange
#region Act
Controller.AddUnit("Name2", "LoginId1", 3);
#endregion Act
}
catch (Exception ex)
{
#region Assert
Assert.IsNotNull(ex);
Assert.AreEqual("UserName does not have access to manage the given unit", ex.Message);
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1"));
UnitAssociationRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <UnitAssociation> .Is.Anything));
#endregion Assert
throw;
}
}
public void TestCanUserManageGivenLogin3()
{
#region Arrange
UserService = new UserService(UnitService, UnitAssociationRepository, PermissionRepository);
ControllerRecordFakes.FakeUnits(6, UnitRepository);
ControllerRecordFakes.FakeRoles(6, RoleRepository);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUsers(6, UserRepository);
//These are the units that the current user has if he has the correct access
UnitService.Expect(a => a.GetVisibleByUser("Name1", "UserName")).Return(UnitRepository.Queryable.Where(a => a.Id == 2 || a.Id == 4)).Repeat.Any();
var unitAssociations = new List <UnitAssociation>();
for (int i = 0; i < 5; i++)
{
unitAssociations.Add(CreateValidEntities.UnitAssociation(i + 1));
unitAssociations[i].User = UserRepository.GetNullableById(3); //Different LoginId
unitAssociations[i].Application = ApplicationRepository.Queryable.First();
unitAssociations[i].Unit = UnitRepository.GetNullableById(i + 1);
}
ControllerRecordFakes.FakeUnitAssociations(0, UnitAssociationRepository, unitAssociations);
#endregion Arrange
#region Act
var result = UserService.CanUserManageGivenLogin("Name1", "UserName", "LoginId2");
#endregion Act
#region Assert
Assert.IsFalse(result);
#endregion Assert
}
public void TestAddPermissionThrowsExceptionIfloginIdDuplicate()
{
try
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeRoles(5, RoleRepository);
var users = new List <User> {
CreateValidEntities.User(1), CreateValidEntities.User(1)
};
ControllerRecordFakes.FakeUsers(3, UserRepository, users);
ControllerRecordFakes.FakePermissions(1, PermissionRepository);
RoleService.Expect(a => a.GetVisibleByUser("Name2", "UserName")).Return(RoleRepository.Queryable).Repeat.Any();
UserService.Expect(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1")).Return(true).Repeat.Any();
PermissionRepository.Expect(a => a.EnsurePersistent(Arg <Permission> .Is.Anything)).Repeat.Any();
#endregion Arrange
#region Act
Controller.AddPermission("Name2", "LoginId1", 3);
#endregion Act
}
catch (Exception ex)
{
#region Assert
Assert.IsNotNull(ex);
Assert.AreEqual("Sequence contains more than one element", ex.Message);
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1"));
RoleService.AssertWasCalled(a => a.GetVisibleByUser("Name2", "UserName"));
PermissionRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <Permission> .Is.Anything));
#endregion Assert
throw;
}
}
public void TestAddUnitWhereUnitAssociationAlreadyExists()
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUnits(3, UnitRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
var unitAssociations = new List <UnitAssociation>();
unitAssociations.Add(CreateValidEntities.UnitAssociation(1));
unitAssociations[0].Application = ApplicationRepository.GetNullableById(2);
unitAssociations[0].User = UserRepository.GetNullableById(1);
unitAssociations[0].Unit = UnitRepository.GetNullableById(3);
ControllerRecordFakes.FakeUnitAssociations(1, UnitAssociationRepository, unitAssociations);
UnitService.Expect(a => a.GetVisibleByUser("Name2", "UserName")).Return(UnitRepository.Queryable).Repeat.Any();
UserService.Expect(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1")).Return(true).Repeat.Any();
UnitAssociationRepository.Expect(a => a.EnsurePersistent(Arg <UnitAssociation> .Is.Anything)).Repeat.Any();
#endregion Arrange
#region Act
Controller.AddUnit("Name2", "LoginId1", 3);
#endregion Act
#region Assert
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1"));
UnitAssociationRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <UnitAssociation> .Is.Anything));
UnitService.AssertWasCalled(a => a.GetVisibleByUser("Name2", "UserName"));
#endregion Assert
}
public void TestAddPermissionWhenPermissionAlreadyExists()
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeRoles(5, RoleRepository);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
var permissions = new List <Permission> {
CreateValidEntities.Permission(1)
};
permissions[0].Application = ApplicationRepository.GetNullableById(3);
permissions[0].User = UserRepository.GetNullableById(3);
permissions[0].Role = RoleRepository.GetNullableById(2);
ControllerRecordFakes.FakePermissions(1, PermissionRepository, permissions);
UserService.Expect(a => a.CanUserManageGivenLogin("Name3", "UserName", "LoginId3")).Return(true).Repeat.Any();
RoleService.Expect(a => a.GetVisibleByUser("Name3", "UserName")).Return(RoleRepository.Queryable).Repeat.Any();
PermissionRepository.Expect(a => a.EnsurePersistent(Arg <Permission> .Is.Anything)).Repeat.Any();
#endregion Arrange
#region Act
Controller.AddPermission("Name3", "LoginId3", 2);
#endregion Act
#region Assert
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name3", "UserName", "LoginId3"));
RoleService.AssertWasCalled(a => a.GetVisibleByUser("Name3", "UserName"));
PermissionRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <Permission> .Is.Anything));
#endregion Assert
}
public void TestRoleServiceGetVisibleByUserReturnsExpectedResults3()
{
#region Arrange
var applicationRoleRepository = FakeRepository <ApplicationRole>();
RoleService = new RoleService(PermissionRepository, applicationRoleRepository);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
ControllerRecordFakes.FakeRoles(10, RoleRepository);
var permissions = new List <Permission>();
for (int i = 0; i < 7; i++)
{
permissions.Add(CreateValidEntities.Permission(i + 1));
permissions[i].Application = ApplicationRepository.Queryable.First();
permissions[i].User = UserRepository.GetNullableById(2);
permissions[i].Role = RoleRepository.GetNullableById(i + 1);
}
permissions[1].Application = ApplicationRepository.GetNullableById(2);
permissions[2].User = UserRepository.GetNullableById(1);
ControllerRecordFakes.FakePermissions(0, PermissionRepository, permissions);
applicationRoleRepository.Expect(a => a.Queryable).Return(new List <ApplicationRole>().AsQueryable()).Repeat.Any();
#endregion Arrange
#region Act
var result = RoleService.GetVisibleByUser("Name2", "LoginId2");
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IQueryable <Role>));
Assert.AreEqual(1, result.Count());
Assert.AreEqual("Name2", result.ElementAt(0).Name);
#endregion Assert
}
public void TestAddUnitThrowsExceptionIfApplicationNotFound()
{
try
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUnits(3, UnitRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
ControllerRecordFakes.FakeUnitAssociations(1, UnitAssociationRepository);
UnitService.Expect(a => a.GetVisibleByUser("Name4", "UserName")).Return(UnitRepository.Queryable).Repeat.Any();
UserService.Expect(a => a.CanUserManageGivenLogin("Name4", "UserName", "LoginId1")).Return(true).Repeat.Any();
UnitAssociationRepository.Expect(a => a.EnsurePersistent(Arg <UnitAssociation> .Is.Anything)).Repeat.Any();
#endregion Arrange
#region Act
Controller.AddUnit("Name4", "LoginId1", 3);
#endregion Act
}
catch (Exception ex)
{
#region Assert
Assert.IsNotNull(ex);
Assert.AreEqual("Sequence contains no elements", ex.Message);
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name4", "UserName", "LoginId1"));
UnitService.AssertWasCalled(a => a.GetVisibleByUser("Name4", "UserName"));
UnitAssociationRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <UnitAssociation> .Is.Anything));
#endregion Assert
throw;
}
}
public void TestRoleServiceGetVisibleByUserReturnsExpectedResults4()
{
#region Arrange
var applicationRoleRepository = FakeRepository <ApplicationRole>();
RoleService = new RoleService(PermissionRepository, applicationRoleRepository);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
ControllerRecordFakes.FakeRoles(10, RoleRepository);
var permissions = new List <Permission>();
for (int i = 0; i < 10; i++)
{
permissions.Add(CreateValidEntities.Permission(i + 1));
permissions[i].Application = ApplicationRepository.Queryable.First();
permissions[i].User = UserRepository.GetNullableById(3);
permissions[i].Role = RoleRepository.GetNullableById(i + 1);
}
permissions[4].User = UserRepository.GetNullableById(2);
ControllerRecordFakes.FakePermissions(0, PermissionRepository, permissions);
var applicationRoles = new List <ApplicationRole>();
for (int i = 0; i < 10; i++)
{
applicationRoles.Add(CreateValidEntities.ApplicationRole(i + 1));
applicationRoles[i].Role = RoleRepository.GetNullableById(i + 1);
applicationRoles[i].Application = ApplicationRepository.GetNullableById(1);
}
ControllerRecordFakes.FakeApplicationRoles(0, applicationRoleRepository, applicationRoles);
#endregion Arrange
#region Act
//var manageableRoles = from ar in applicationRoleRepository.Queryable
// where ar.Application.Name == "Name1" &&
// ar.Level > (
// (from p in PermissionRepository.Queryable
// join a in applicationRoleRepository.Queryable on
// new { Role = p.Role.Id, App = p.Application.Id }
// equals new { Role = a.Role.Id, App = a.Application.Id }
// where p.Application.Name == "Name1" &&
// p.User.LoginId == "LoginId2" &&
// a.Level != null
// select a.Level).Max()
// )
// select ar.Role;
var result = RoleService.GetVisibleByUser("Name1", "LoginId2");
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IQueryable <Role>));
Assert.AreEqual(6, result.Count());
for (int i = 1; i < 6; i++)
{
Assert.AreEqual(string.Format("Name{0}", (i + 4)), result.ElementAt(i).Name);
}
#endregion Assert
}
public void TestInsertNewUserThrowsExceptionIfNewUserIsNotValid()
{
const string applicationName = "SomeApp";
ControllerRecordFakes.FakeUsers(3, UserRepository);
AutomapperConfig.Configure();
try
{
#region Arrange
var serviceUser = new ServiceUser();
serviceUser.Login = null;
serviceUser.LastName = null;
serviceUser.FirstName = "FirstName";
#endregion Arrange
#region Act
Controller.InsertNewUser(applicationName, serviceUser, 1, 1);
#endregion Act
}
catch (Exception ex)
{
Assert.IsNotNull(ex);
Assert.AreEqual("User not valid: may not be null or empty", ex.Message);
throw;
}
}
public void TestGetVisibleByUserReturnsExpectedResults1()
{
#region Arrange
IRepository <School> schoolRepository = FakeRepository <School>();
Controller.Repository.Expect(a => a.OfType <School>()).Return(schoolRepository).Repeat.Any();
UnitService = new UnitService(RoleService, schoolRepository, UnitRepository, UnitAssociationRepository);
var roles = new List <Role>();
roles.Add(CreateValidEntities.Role(1));
roles[0].Name = "ManageAll";
roles.Add(CreateValidEntities.Role(2));
roles[1].Name = "ManageSchool";
ControllerRecordFakes.FakeRoles(5, RoleRepository, roles);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUnits(3, UnitRepository);
RoleService.Expect(a => a.GetManagementRolesForUserInApplication("Name2", "UserName")).Return(RoleRepository.Queryable.Select(a => a.Name).ToList()).Repeat.Any();
#endregion Arrange
#region Act
var result = UnitService.GetVisibleByUser("Name2", "UserName");
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IQueryable <Unit>));
Assert.AreEqual(3, result.Count());
Assert.AreEqual("ShortName2", result.ElementAt(1).ShortName);
#endregion Assert
}
public void TestInsertNewUserReturnsExpectedValue1()
{
#region Arrange
const string applicationName = "Name2";
ControllerRecordFakes.FakeUsers(3, UserRepository);
AutomapperConfig.Configure();
var serviceUser = CreateValidEntities.ServiceUser(4);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeRoles(3, RoleRepository);
ControllerRecordFakes.FakeUnits(3, UnitRepository);
ControllerRecordFakes.FakePermissions(3, PermissionRepository);
ControllerRecordFakes.FakeUnitAssociations(3, UnitAssociationRepository);
#endregion Arrange
#region Act
var result = Controller.InsertNewUser(applicationName, serviceUser, 3, 2)
.AssertResultIs <JsonResult>();
#endregion Act
#region Assert
Assert.IsNotNull(result);
var result2 = (ServiceUser)result.Data;
Assert.IsNotNull(result2);
Assert.AreEqual("*****@*****.**", result2.Email);
Assert.AreEqual("FirstName4", result2.FirstName);
Assert.AreEqual("LastName4", result2.LastName);
Assert.AreEqual("LoginId4", result2.Login);
Assert.AreEqual("+1 530 755 7777", result2.Phone);
UserRepository.AssertWasCalled(a => a.EnsurePersistent(Arg <User> .Is.Anything));
var userArgs = (User)UserRepository.GetArgumentsForCallsMadeOn(a => a.EnsurePersistent(Arg <User> .Is.Anything))[0][0];
Assert.AreEqual("*****@*****.**", userArgs.Email);
Assert.AreEqual("FirstName4", userArgs.FirstName);
Assert.IsFalse(userArgs.Inactive);
Assert.AreEqual("LastName4", userArgs.LastName);
Assert.AreEqual("LoginId4", userArgs.LoginId);
Assert.AreEqual("+1 530 755 7777", userArgs.Phone);
PermissionRepository.AssertWasCalled(a => a.EnsurePersistent(Arg <Permission> .Is.Anything));
var permissionArgs = (Permission)PermissionRepository.GetArgumentsForCallsMadeOn(a => a.EnsurePersistent(Arg <Permission> .Is.Anything))[0][0];
Assert.IsNotNull(permissionArgs);
Assert.AreEqual(applicationName, permissionArgs.Application.ToString());
Assert.AreEqual("Name3", permissionArgs.Role.Name);
Assert.IsFalse(permissionArgs.Inactive);
Assert.AreEqual(userArgs.LoginId, permissionArgs.User.LoginId);
UnitAssociationRepository.AssertWasCalled(a => a.EnsurePersistent(Arg <UnitAssociation> .Is.Anything));
var unitAssociationArgs = (UnitAssociation)UnitAssociationRepository.GetArgumentsForCallsMadeOn(a => a.EnsurePersistent(Arg <UnitAssociation> .Is.Anything))[0][0];
Assert.IsNotNull(unitAssociationArgs);
Assert.AreEqual(applicationName, unitAssociationArgs.Application.ToString());
Assert.AreEqual("ShortName2", unitAssociationArgs.Unit.ShortName);
Assert.IsFalse(unitAssociationArgs.Inactive);
Assert.AreEqual(userArgs.LoginId, unitAssociationArgs.User.LoginId);
#endregion Assert
}
public void TestManageReturnsView4()
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeUnits(3, UnitRepository);
UnitService.Expect(a => a.GetVisibleByUser("appName", "UserName")).Return(UnitRepository.GetAll().AsQueryable()).Repeat.Any();
ControllerRecordFakes.FakeRoles(3, RoleRepository);
RoleService.Expect(a => a.GetVisibleByUser("appName", "UserName")).Return(RoleRepository.GetAll().AsQueryable()).Repeat.Any();
ControllerRecordFakes.FakeUsers(3, UserRepository);
UserService.Expect(a => a.GetByApplication("appName", "UserName")).Return(UserRepository.Queryable).Repeat.Any();
var application = CreateValidEntities.Application(1);
application.Name = "appName";
var permissions = new List <Permission>();
for (int i = 0; i < 4; i++)
{
permissions.Add(CreateValidEntities.Permission(i + 1));
permissions[i].Application = application;
permissions[i].User = UserRepository.Queryable.First();
permissions[i].Role = RoleRepository.GetNullableById(i + 1);
}
permissions[1].User = UserRepository.GetNullableById(2);
permissions[2].User = UserRepository.GetNullableById(3);
permissions[3].Role = RoleRepository.GetNullableById(1);
permissions[3].Application = CreateValidEntities.Application(9); // This will cause these permissions to be filtered out
ControllerRecordFakes.FakePermissions(0, PermissionRepository, permissions);
var unitAssociations = new List <UnitAssociation>();
for (int i = 0; i < 4; i++)
{
unitAssociations.Add(CreateValidEntities.UnitAssociation(i + 1));
unitAssociations[i].Application = application;
unitAssociations[i].User = UserRepository.Queryable.First();
unitAssociations[i].Unit = UnitRepository.GetNullableById(i + 1);
}
unitAssociations[1].User = UserRepository.GetNullableById(2);
unitAssociations[2].User = UserRepository.GetNullableById(3);
unitAssociations[2].Application = CreateValidEntities.Application(9); //This one is filtered out
unitAssociations[3].Unit = UnitRepository.GetNullableById(1);
ControllerRecordFakes.FakeUnitAssociations(0, UnitAssociationRepository, unitAssociations);
#endregion Arrange
#region Act
Controller.Manage("appName")
.AssertViewRendered()
.WithViewData <UserManagementViewModel>();
#endregion Act
#region Assert
UnitService.AssertWasCalled(a => a.GetVisibleByUser("appName", "UserName"));
RoleService.AssertWasCalled(a => a.GetVisibleByUser("appName", "UserName"));
UserService.AssertWasCalled(a => a.GetByApplication("appName", "UserName"));
#endregion Assert
}
public void TestRemoveUnitThrowsExceptionIfRecordNotFound4()
{
try
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUnits(3, UnitRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
var unitAssociations = new List <UnitAssociation>();
for (int i = 0; i < 3; i++)
{
unitAssociations.Add(CreateValidEntities.UnitAssociation(i + 1));
unitAssociations[i].Application = ApplicationRepository.GetNullableById(2);
unitAssociations[i].User = UserRepository.GetNullableById(1);
unitAssociations[i].Unit = UnitRepository.GetNullableById(i + 1);
}
unitAssociations.Add(CreateValidEntities.UnitAssociation(4));
unitAssociations[3].Application = ApplicationRepository.GetNullableById(2);
unitAssociations[3].User = UserRepository.GetNullableById(1);
unitAssociations[3].Unit = UnitRepository.GetNullableById(2); //Duplicate
ControllerRecordFakes.FakeUnitAssociations(2, UnitAssociationRepository, unitAssociations);
UserService.Expect(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1")).Return(true).Repeat.Any();
UnitService.Expect(a => a.GetVisibleByUser("Name2", "UserName")).Return(UnitRepository.Queryable).Repeat.Any();
#endregion Arrange
#region Act
Controller.RemoveUnit("Name2", "LoginId1", 2);
#endregion Act
}
catch (Exception ex)
{
#region Assert
Assert.IsNotNull(ex);
Assert.AreEqual("Sequence contains more than one element", ex.Message);
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1"));
UnitService.AssertWasCalled(a => a.GetVisibleByUser("Name2", "UserName"));
UnitAssociationRepository.AssertWasNotCalled(a => a.Remove(Arg <UnitAssociation> .Is.Anything));
#endregion Assert
throw;
}
}
public void TestGetManagementRolesForUserInApplicationReturnsExpectedValue1()
{
#region Arrange
var applicationRoleRepository = FakeRepository <ApplicationRole>();
RoleService = new RoleService(PermissionRepository, applicationRoleRepository);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
var roles = new List <Role>();
roles.Add(CreateValidEntities.Role(1));
roles.Add(CreateValidEntities.Role(2));
roles.Add(CreateValidEntities.Role(3));
roles.Add(CreateValidEntities.Role(4));
roles[0].Name = "ManageAll";
roles[1].Name = "ManageSchool";
roles[2].Name = "ManageUnit";
roles[3].Name = "ManageMe"; //Not special
ControllerRecordFakes.FakeRoles(5, RoleRepository, roles);
var permissions = new List <Permission>();
for (int i = 0; i < 6; i++)
{
permissions.Add(CreateValidEntities.Permission(i + 1));
permissions[i].Application = ApplicationRepository.GetNullableById(1);
permissions[i].User = UserRepository.GetNullableById(2);
permissions[i].Role = RoleRepository.GetNullableById(i + 1);
}
ControllerRecordFakes.FakePermissions(6, PermissionRepository, permissions);
#endregion Arrange
#region Act
var result = RoleService.GetManagementRolesForUserInApplication("Name1", "LoginId2");
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(4, result.Count);
Assert.AreEqual("ManageAll", result.ElementAt(0));
Assert.AreEqual("ManageSchool", result.ElementAt(1));
Assert.AreEqual("ManageUnit", result.ElementAt(2));
Assert.AreEqual("ManageMe", result.ElementAt(3));
#endregion Assert
}
public void TestRemovePermissionThrowsExceptionPermissionNotUnique()
{
try
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
ControllerRecordFakes.FakeRoles(5, RoleRepository);
var permissions = new List <Permission>();
for (int i = 0; i < 3; i++)
{
permissions.Add(CreateValidEntities.Permission(i + 1));
permissions[i].User = UserRepository.GetNullableById(1);
permissions[i].Application = ApplicationRepository.GetNullableById(2);
permissions[i].Role = RoleRepository.GetNullableById(i + 1);
}
permissions[1].Role = RoleRepository.GetNullableById(1);
ControllerRecordFakes.FakePermissions(1, PermissionRepository, permissions);
UserService.Expect(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1")).Return(true).Repeat.Any();
RoleService.Expect(a => a.GetVisibleByUser("Name2", "UserName")).Return(RoleRepository.Queryable).Repeat.Any();
PermissionRepository.Expect(a => a.Remove(Arg <Permission> .Is.Anything)).Repeat.Any();
#endregion Arrange
#region Act
Controller.RemovePermission("Name2", "LoginId1", 1);
#endregion Act
}
catch (Exception ex)
{
#region Assert
Assert.IsNotNull(ex);
Assert.AreEqual("Sequence contains more than one element", ex.Message);
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1"));
RoleService.AssertWasCalled(a => a.GetVisibleByUser("Name2", "UserName"));
PermissionRepository.AssertWasNotCalled(a => a.Remove(Arg <Permission> .Is.Anything));
#endregion Assert
throw;
}
}
public void TestLoadUserThrowsExceptionIfUserNotFound()
{
try
{
#region Arrange
ControllerRecordFakes.FakeUsers(3, UserRepository);
#endregion Arrange
#region Act
Controller.LoadUser("blah", "LoginId4");
#endregion Act
}
catch (Exception ex)
{
#region Assert
Assert.IsNotNull(ex);
Assert.AreEqual("Sequence contains no elements", ex.Message);
#endregion Assert
throw;
}
}
public void TestCanUserManageGivenLogin1()
{
#region Arrange
UserService = new UserService(UnitService, UnitAssociationRepository, PermissionRepository);
ControllerRecordFakes.FakeUnits(6, UnitRepository);
ControllerRecordFakes.FakeRoles(6, RoleRepository);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUsers(6, UserRepository);
//These are the units that the current user has if he has the correct access
UnitService.Expect(a => a.GetVisibleByUser("Name1", "UserName")).Return(UnitRepository.Queryable.Where(a => a.Id == 2 || a.Id == 4)).Repeat.Any();
var unitAssociations = new List <UnitAssociation>();
for (int i = 0; i < 5; i++)
{
unitAssociations.Add(CreateValidEntities.UnitAssociation(i + 1));
unitAssociations[i].User = UserRepository.GetNullableById(i + 1);
unitAssociations[i].Application = ApplicationRepository.Queryable.First();
unitAssociations[i].Unit = UnitRepository.GetNullableById(i + 1);
}
ControllerRecordFakes.FakeUnitAssociations(0, UnitAssociationRepository, unitAssociations);
#endregion Arrange
#region Act
var result = UserService.CanUserManageGivenLogin("Name1", "UserName", "LoginId2");
//var unitsForLoginToManage = from u in UnitAssociationRepository.Queryable
// where u.Application.Name == "Name1"
// && u.User.LoginId == "LoginId2"
// select u.Unit;
//var numIntersectingUnits1 = unitsForLoginToManage.ToFuture();
////The linq provider can't handle Intersect() so we need to turn them into Enumerable first.
////Using to future does this and makes the queries more efficient by batching them
//var numIntersectingUnits = unitsForLoginToManage.ToFuture().Intersect(UnitRepository.Queryable.Where(a => a.Id == 2 || a.Id == 4).ToFuture()).Count();
#endregion Act
#region Assert
Assert.IsTrue(result);
#endregion Assert
}
public void TestRemovePermissionThrowsExceptionIfCurrentUserDoesNotHaveRights1()
{
try
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
ControllerRecordFakes.FakeRoles(5, RoleRepository);
var permissions = new List <Permission>();
for (int i = 0; i < 3; i++)
{
permissions.Add(CreateValidEntities.Permission(i + 1));
permissions[i].User = UserRepository.GetNullableById(1);
permissions[i].Application = ApplicationRepository.GetNullableById(2);
permissions[i].Role = RoleRepository.GetNullableById(i + 1);
}
permissions[1].Role = RoleRepository.GetNullableById(4);
ControllerRecordFakes.FakePermissions(1, PermissionRepository, permissions);
UserService.Expect(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1")).Return(false).Repeat.Any();
PermissionRepository.Expect(a => a.Remove(Arg <Permission> .Is.Anything)).Repeat.Any();
#endregion Arrange
#region Act
Controller.RemovePermission("Name2", "LoginId1", 4);
#endregion Act
}
catch (Exception ex)
{
#region Assert
Assert.IsNotNull(ex);
Assert.AreEqual("UserName does not have access to manage LoginId1 within the Name2 application", ex.Message);
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1"));
PermissionRepository.AssertWasNotCalled(a => a.Remove(Arg <Permission> .Is.Anything));
#endregion Assert
throw;
}
}
public void TestLoadUserThrowsExceptionIfTwoUsersFound()
{
try
{
#region Arrange
var users = new List <User>();
users.Add(CreateValidEntities.User(2));
ControllerRecordFakes.FakeUsers(3, UserRepository, users);
#endregion Arrange
#region Act
Controller.LoadUser("blah", "LoginId2");
#endregion Act
}
catch (Exception ex)
{
#region Assert
Assert.IsNotNull(ex);
Assert.AreEqual("Sequence contains more than one element", ex.Message);
#endregion Assert
throw;
}
}
public void TestRemovePermission()
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
ControllerRecordFakes.FakeRoles(5, RoleRepository);
var permissions = new List <Permission>();
for (int i = 0; i < 3; i++)
{
permissions.Add(CreateValidEntities.Permission(i + 1));
permissions[i].User = UserRepository.GetNullableById(1);
permissions[i].Application = ApplicationRepository.GetNullableById(2);
permissions[i].Role = RoleRepository.GetNullableById(i + 1);
}
permissions[1].Role = RoleRepository.GetNullableById(4);
ControllerRecordFakes.FakePermissions(1, PermissionRepository, permissions);
UserService.Expect(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1")).Return(true).Repeat.Any();
RoleService.Expect(a => a.GetVisibleByUser("Name2", "UserName")).Return(RoleRepository.Queryable).Repeat.Any();
PermissionRepository.Expect(a => a.Remove(Arg <Permission> .Is.Anything)).Repeat.Any();
#endregion Arrange
#region Act
Controller.RemovePermission("Name2", "LoginId1", 4);
#endregion Act
#region Assert
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1"));
RoleService.AssertWasCalled(a => a.GetVisibleByUser("Name2", "UserName"));
PermissionRepository.AssertWasCalled(a => a.Remove(Arg <Permission> .Is.Anything));
var args = (Permission)PermissionRepository.GetArgumentsForCallsMadeOn(a => a.Remove(Arg <Permission> .Is.Anything))[0][0];
Assert.IsNotNull(args);
Assert.AreEqual("Name4", args.Role.Name);
Assert.AreEqual("LoginId1", args.User.LoginId);
Assert.AreEqual("Name2", args.Application.ToString());
#endregion Assert
}
public void TestRemoveUnit()
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUnits(3, UnitRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
var unitAssociations = new List <UnitAssociation>();
for (int i = 0; i < 3; i++)
{
unitAssociations.Add(CreateValidEntities.UnitAssociation(i + 1));
unitAssociations[i].Application = ApplicationRepository.GetNullableById(2);
unitAssociations[i].User = UserRepository.GetNullableById(1);
unitAssociations[i].Unit = UnitRepository.GetNullableById(i + 1);
}
ControllerRecordFakes.FakeUnitAssociations(2, UnitAssociationRepository, unitAssociations);
UserService.Expect(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1")).Return(true).Repeat.Any();
UnitService.Expect(a => a.GetVisibleByUser("Name2", "UserName")).Return(UnitRepository.Queryable).Repeat.Any();
#endregion Arrange
#region Act
Controller.RemoveUnit("Name2", "LoginId1", 2);
#endregion Act
#region Assert
UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1"));
UnitService.AssertWasCalled(a => a.GetVisibleByUser("Name2", "UserName"));
UnitAssociationRepository.AssertWasCalled(a => a.Remove(Arg <UnitAssociation> .Is.Anything));
var args = (UnitAssociation)UnitAssociationRepository.GetArgumentsForCallsMadeOn(a => a.Remove(Arg <UnitAssociation> .Is.Anything))[0][0];
Assert.AreEqual(2, args.Id);
Assert.AreEqual("ShortName2", args.Unit.ShortName);
Assert.AreEqual("LoginId1", args.User.LoginId);
Assert.AreEqual("Name2", args.Application.ToString());
#endregion Assert
}
public void TestManageReturnsView2()
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" });
ControllerRecordFakes.FakeUnits(3, UnitRepository);
UnitService.Expect(a => a.GetVisibleByUser("appName", "UserName")).Return(UnitRepository.GetAll().AsQueryable()).Repeat.Any();
ControllerRecordFakes.FakeRoles(3, RoleRepository);
RoleService.Expect(a => a.GetVisibleByUser("appName", "UserName")).Return(RoleRepository.GetAll().AsQueryable()).Repeat.Any();
ControllerRecordFakes.FakeUsers(3, UserRepository);
UserService.Expect(a => a.GetByApplication("appName", "UserName")).Return(UserRepository.Queryable).Repeat.Any();
var application = CreateValidEntities.Application(1);
application.Name = "appName";
var permissions = new List <Permission>();
for (int i = 0; i < 4; i++)
{
permissions.Add(CreateValidEntities.Permission(i + 1));
permissions[i].Application = application;
permissions[i].User = UserRepository.Queryable.First();
permissions[i].Role = RoleRepository.GetNullableById(i + 1);
}
permissions[1].User = UserRepository.GetNullableById(2);
permissions[2].User = UserRepository.GetNullableById(3);
permissions[3].Role = RoleRepository.GetNullableById(1);
ControllerRecordFakes.FakePermissions(0, PermissionRepository, permissions);
var unitAssociations = new List <UnitAssociation>();
for (int i = 0; i < 4; i++)
{
unitAssociations.Add(CreateValidEntities.UnitAssociation(i + 1));
unitAssociations[i].Application = application;
unitAssociations[i].User = UserRepository.Queryable.First();
unitAssociations[i].Unit = UnitRepository.GetNullableById(i + 1);
}
unitAssociations[1].User = UserRepository.GetNullableById(2);
unitAssociations[2].User = UserRepository.GetNullableById(3);
unitAssociations[3].Unit = UnitRepository.GetNullableById(1);
ControllerRecordFakes.FakeUnitAssociations(0, UnitAssociationRepository, unitAssociations);
#endregion Arrange
#region Act
var result = Controller.Manage("appName")
.AssertViewRendered()
.WithViewData <UserManagementViewModel>();
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual("appName", result.Application);
Assert.AreEqual(3, result.Roles.Count);
Assert.AreEqual("Name2", result.Roles[1].Value);
Assert.AreEqual(3, result.Units.Count);
Assert.AreEqual("ShortName2", result.Units[1].Value);
Assert.AreEqual(3, result.UserShowModel.Count);
Assert.AreEqual("FirstName2", result.UserShowModel[1].FirstName);
Assert.AreEqual("LastName2", result.UserShowModel[1].LastName);
Assert.AreEqual("*****@*****.**", result.UserShowModel[1].Email);
Assert.AreEqual("LoginId2", result.UserShowModel[1].Login);
Assert.AreEqual(null, result.UserShowModel[1].Phone);
Assert.AreEqual(2, result.UserShowModel[0].Permissions.Count);
Assert.AreEqual("Name1", result.UserShowModel[0].Permissions[1].RoleName);
Assert.AreEqual("Name1", result.UserShowModel[0].Permissions[0].RoleName);
Assert.AreEqual(2, result.UserShowModel[0].UnitAssociations.Count);
Assert.AreEqual("ShortName1", result.UserShowModel[0].UnitAssociations[1].UnitName);
Assert.AreEqual("ShortName1", result.UserShowModel[0].UnitAssociations[0].UnitName);
Assert.AreEqual(1, result.UserShowModel[1].Permissions.Count);
Assert.AreEqual("Name2", result.UserShowModel[1].Permissions[0].RoleName);
Assert.AreEqual(1, result.UserShowModel[1].UnitAssociations.Count);
Assert.AreEqual("ShortName2", result.UserShowModel[1].UnitAssociations[0].UnitName);
Assert.AreEqual(1, result.UserShowModel[2].Permissions.Count);
Assert.AreEqual("Name3", result.UserShowModel[2].Permissions[0].RoleName);
Assert.AreEqual(1, result.UserShowModel[2].UnitAssociations.Count);
Assert.AreEqual("ShortName3", result.UserShowModel[2].UnitAssociations[0].UnitName);
#endregion Assert
}
public void TestInsertNewUserReturnsExpectedValue3()
{
#region Arrange
const string applicationName = "Name2";
var users = new List <User>();
users.Add(CreateValidEntities.User(4));
ControllerRecordFakes.FakeUsers(0, UserRepository, users);
AutomapperConfig.Configure();
var serviceUser = CreateValidEntities.ServiceUser(4);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeRoles(3, RoleRepository);
ControllerRecordFakes.FakeUnits(3, UnitRepository);
var permissions = new List <Permission>();
permissions.Add(CreateValidEntities.Permission(1));
permissions[0].Application = ApplicationRepository.GetNullableById(2);
permissions[0].User = users[0];
permissions[0].Role = RoleRepository.GetNullableById(3);
permissions.Add(CreateValidEntities.Permission(2));
permissions[1].Application = ApplicationRepository.GetNullableById(2);
permissions[1].User = users[0];
permissions[1].Role = RoleRepository.GetNullableById(1);
ControllerRecordFakes.FakePermissions(0, PermissionRepository, permissions);
var unitAssociations = new List <UnitAssociation>();
unitAssociations.Add(CreateValidEntities.UnitAssociation(1));
unitAssociations[0].Application = ApplicationRepository.GetNullableById(2);
unitAssociations[0].User = users[0];
unitAssociations[0].Unit = UnitRepository.GetNullableById(2);
unitAssociations.Add(CreateValidEntities.UnitAssociation(2));
unitAssociations[1].Application = ApplicationRepository.GetNullableById(2);
unitAssociations[1].User = users[0];
unitAssociations[1].Unit = UnitRepository.GetNullableById(1);
ControllerRecordFakes.FakeUnitAssociations(0, UnitAssociationRepository, unitAssociations);
#endregion Arrange
#region Act
var result = Controller.InsertNewUser(applicationName, serviceUser, 3, 2)
.AssertResultIs <JsonResult>();
#endregion Act
#region Assert
Assert.IsNotNull(result);
var result2 = (ServiceUser)result.Data;
Assert.IsNotNull(result2);
Assert.AreEqual("*****@*****.**", result2.Email);
Assert.AreEqual("FirstName4", result2.FirstName);
Assert.AreEqual("LastName4", result2.LastName);
Assert.AreEqual("LoginId4", result2.Login);
Assert.AreEqual("+1 530 755 7777", result2.Phone);
Assert.AreEqual("Name1, Name3", result2.Roles);
Assert.AreEqual("ShortName1, ShortName2", result2.Units);
UserRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <User> .Is.Anything));
PermissionRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <Permission> .Is.Anything));
UnitAssociationRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <UnitAssociation> .Is.Anything));
#endregion Assert
}
public void TestGetVisibleByUserReturnsExpectedResults4()
{
#region Arrange
var schoolRepository = FakeRepository <School>();
Controller.Repository.Expect(a => a.OfType <School>()).Return(schoolRepository).Repeat.Any();
UnitService = new UnitService(RoleService, schoolRepository, UnitRepository, UnitAssociationRepository);
var roles = new List <Role>();
roles.Add(CreateValidEntities.Role(1));
roles[0].Name = "ManageNot";
roles.Add(CreateValidEntities.Role(2));
roles[1].Name = "ManageUnit";
ControllerRecordFakes.FakeRoles(5, RoleRepository, roles);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
var schools = new List <School>();
schools.Add(CreateValidEntities.School(1));
schools[0].Units = new List <Unit>();
schools[0].Units.Add(CreateValidEntities.Unit(1));
schools[0].Units[0].SetIdTo(1);
schools[0].Units.Add(CreateValidEntities.Unit(2));
schools[0].Units[0].SetIdTo(2);
ControllerRecordFakes.FakeSchools(3, schoolRepository, schools);
var units = new List <Unit>();
units.Add(CreateValidEntities.Unit(1));
units.Add(CreateValidEntities.Unit(2));
units.Add(CreateValidEntities.Unit(3));
units[0].School = schoolRepository.Queryable.First();
units[1].School = schoolRepository.GetNullableById(2);
units[2].School = schoolRepository.Queryable.First();
var unitAssociations = new List <UnitAssociation>();
unitAssociations.Add(CreateValidEntities.UnitAssociation(1));
unitAssociations.Add(CreateValidEntities.UnitAssociation(2));
unitAssociations.Add(CreateValidEntities.UnitAssociation(3));
unitAssociations[0].Application = ApplicationRepository.GetNullableById(2);
unitAssociations[0].Unit = units[0];
unitAssociations[0].Unit.School = CreateValidEntities.School(1);
unitAssociations[0].Unit.School.SetId("1");
unitAssociations[0].User = CreateValidEntities.User(1);
unitAssociations[0].User.LoginId = "UserName";
unitAssociations[1].Application = ApplicationRepository.GetNullableById(1);
unitAssociations[1].Unit = units[1];
unitAssociations[1].Unit.School = CreateValidEntities.School(1);
unitAssociations[1].Unit.School.SetId("1");
unitAssociations[1].User = CreateValidEntities.User(1);
unitAssociations[1].User.LoginId = "UserName";
unitAssociations[2].Application = ApplicationRepository.GetNullableById(2);
unitAssociations[2].Unit = units[2];
unitAssociations[2].Unit.School = CreateValidEntities.School(1);
unitAssociations[2].Unit.School.SetId("1");
unitAssociations[2].User = CreateValidEntities.User(1);
unitAssociations[2].User.LoginId = "UserNameNot";
units[0].UnitAssociations = new List <UnitAssociation>();
units[1].UnitAssociations = new List <UnitAssociation>();
units[2].UnitAssociations = new List <UnitAssociation>();
units[0].UnitAssociations.Add(unitAssociations[0]);
units[1].UnitAssociations.Add(unitAssociations[1]);
units[1].UnitAssociations.Add(unitAssociations[2]);
ControllerRecordFakes.FakeUnits(2, UnitRepository, units);
ControllerRecordFakes.FakeUnitAssociations(0, UnitAssociationRepository, unitAssociations);
RoleService.Expect(a => a.GetManagementRolesForUserInApplication("Name2", "UserName")).Return(RoleRepository.Queryable.Select(a => a.Name).ToList()).Repeat.Any();
#endregion Arrange
#region Act
var result = UnitService.GetVisibleByUser("Name2", "UserName");
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IQueryable <Unit>));
Assert.AreEqual(1, result.Count());
Assert.AreEqual("ShortName1", result.ElementAt(0).ShortName);
#endregion Assert
}
public void TestGetByApplication2()
{
#region Arrange
UserService = new UserService(UnitService, UnitAssociationRepository, PermissionRepository);
ControllerRecordFakes.FakeUnits(6, UnitRepository);
ControllerRecordFakes.FakeRoles(6, RoleRepository);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
//These are the units that the current user has if he has the correct access
UnitService.Expect(a => a.GetVisibleByUser("Name1", "UserName")).Return(UnitRepository.Queryable.Where(a => a.Id == 2 || a.Id == 4)).Repeat.Any();
var users = new List <User>();
//User 1 has Unit 1, unit 3 -- no match
users.Add(CreateValidEntities.User(1));
users[0].UnitAssociations.Add(CreateValidEntities.UnitAssociation(1));
users[0].UnitAssociations.Add(CreateValidEntities.UnitAssociation(2));
users[0].UnitAssociations[0].Unit = UnitRepository.GetNullableById(1);
users[0].UnitAssociations[1].Unit = UnitRepository.GetNullableById(3);
//User2 has unit1, 2, 3, and 4 //Match
users.Add(CreateValidEntities.User(2));
users[1].UnitAssociations.Add(CreateValidEntities.UnitAssociation(3));
users[1].UnitAssociations.Add(CreateValidEntities.UnitAssociation(4));
users[1].UnitAssociations.Add(CreateValidEntities.UnitAssociation(5));
users[1].UnitAssociations.Add(CreateValidEntities.UnitAssociation(6));
users[1].UnitAssociations[0].Unit = UnitRepository.GetNullableById(1);
users[1].UnitAssociations[1].Unit = UnitRepository.GetNullableById(2);
users[1].UnitAssociations[2].Unit = UnitRepository.GetNullableById(3);
users[1].UnitAssociations[3].Unit = UnitRepository.GetNullableById(4);
//User3 has unit 4 //Match
users.Add(CreateValidEntities.User(3));
users[2].UnitAssociations.Add(CreateValidEntities.UnitAssociation(7));
users[2].UnitAssociations[0].Unit = UnitRepository.GetNullableById(4);
//user4 has unit2 //match
users.Add(CreateValidEntities.User(4));
users[3].UnitAssociations.Add(CreateValidEntities.UnitAssociation(8));
users[3].UnitAssociations[0].Unit = UnitRepository.GetNullableById(2);
//user5 has unit 5 and 1, no match
users.Add(CreateValidEntities.User(5));
users[4].UnitAssociations.Add(CreateValidEntities.UnitAssociation(9));
users[4].UnitAssociations.Add(CreateValidEntities.UnitAssociation(10));
users[4].UnitAssociations[0].Unit = UnitRepository.GetNullableById(5);
users[4].UnitAssociations[1].Unit = UnitRepository.GetNullableById(1);
ControllerRecordFakes.FakeUsers(0, UserRepository, users);
var permissions = new List <Permission>();
var count = 0;
for (int i = 0; i < 5; i++)
{
for (int x = 0; x < 5; x++)
{
count++;
permissions.Add(CreateValidEntities.Permission(count));
permissions[count - 1].User = UserRepository.GetNullableById(x + 1);
permissions[count - 1].Application = ApplicationRepository.Queryable.First();
permissions[count - 1].Role = RoleRepository.GetNullableById(x + 1);
}
}
ControllerRecordFakes.FakePermissions(0, PermissionRepository, permissions);
var unitAssociations = new List <UnitAssociation>();
for (int i = 0; i < 10; i++)
{
unitAssociations.Add(CreateValidEntities.UnitAssociation(i + 1));
}
unitAssociations[0].User = UserRepository.GetNullableById(1);
unitAssociations[0].Application = ApplicationRepository.Queryable.First();
unitAssociations[0].Unit = UnitRepository.GetNullableById(1);
unitAssociations[1].User = UserRepository.GetNullableById(1);
unitAssociations[1].Application = ApplicationRepository.Queryable.First();
unitAssociations[1].Unit = UnitRepository.GetNullableById(3);
unitAssociations[2].User = UserRepository.GetNullableById(2);
unitAssociations[2].Application = ApplicationRepository.Queryable.First();
unitAssociations[2].Unit = UnitRepository.GetNullableById(1);
unitAssociations[3].User = UserRepository.GetNullableById(2);
unitAssociations[3].Application = ApplicationRepository.Queryable.First();
unitAssociations[3].Unit = UnitRepository.GetNullableById(2);
unitAssociations[4].User = UserRepository.GetNullableById(2);
unitAssociations[4].Application = ApplicationRepository.Queryable.First();
unitAssociations[4].Unit = UnitRepository.GetNullableById(3);
unitAssociations[5].User = UserRepository.GetNullableById(2);
unitAssociations[5].Application = ApplicationRepository.Queryable.First();
unitAssociations[5].Unit = UnitRepository.GetNullableById(4);
unitAssociations[6].User = UserRepository.GetNullableById(3);
unitAssociations[6].Application = ApplicationRepository.Queryable.First();
unitAssociations[6].Unit = UnitRepository.GetNullableById(4);
unitAssociations[7].User = UserRepository.GetNullableById(4);
unitAssociations[7].Application = ApplicationRepository.Queryable.First();
unitAssociations[7].Unit = UnitRepository.GetNullableById(2);
unitAssociations[8].User = UserRepository.GetNullableById(5);
unitAssociations[8].Application = ApplicationRepository.Queryable.First();
unitAssociations[8].Unit = UnitRepository.GetNullableById(5);
unitAssociations[9].User = UserRepository.GetNullableById(5);
unitAssociations[9].Application = ApplicationRepository.Queryable.First();
unitAssociations[9].Unit = UnitRepository.GetNullableById(1);
ControllerRecordFakes.FakeUnitAssociations(0, UnitAssociationRepository, unitAssociations);
#endregion Arrange
#region Act
var result = UserService.GetByApplication("Name1", "UserName");
//var allowedUnitIds = UnitService.GetVisibleByUser("Name1", "UserName").ToList().Select(x => x.Id).ToList();
////Get everyone with perms, possibly filtered by role and unit
//var usersWithPermissions = from p in PermissionRepository.Queryable
// join u in UnitAssociationRepository.Queryable on
// new { User = p.User.Id, App = p.Application.Id }
// equals new { User = u.User.Id, App = u.Application.Id }
// where p.Application.Name == "Name1"
// where p.User.UnitAssociations.Any(a => allowedUnitIds.Contains(a.Unit.Id))
// select new { Permissions = p, UnitAssociations = u };
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Count());
Assert.AreEqual("LoginId2", result.ElementAt(0).LoginId);
Assert.AreEqual("LoginId3", result.ElementAt(1).LoginId);
Assert.AreEqual("LoginId4", result.ElementAt(2).LoginId);
#endregion Assert
}
public void TestLoadUserReturnsExpectedResult()
{
#region Arrange
AutomapperConfig.Configure();
ControllerRecordFakes.FakeUsers(3, UserRepository);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeRoles(5, RoleRepository);
ControllerRecordFakes.FakeUnits(6, UnitRepository);
var permissions = new List <Permission>();
for (int i = 0; i < 3; i++)
{
permissions.Add(CreateValidEntities.Permission(i + 1));
permissions[i].Application = ApplicationRepository.GetNullableById(1);
permissions[i].User = UserRepository.GetNullableById(2);
permissions[i].Role = RoleRepository.GetNullableById(i + 1);
}
permissions[2].Role = RoleRepository.Queryable.Last();
ControllerRecordFakes.FakePermissions(4, PermissionRepository, permissions); //Total of 7, but only 3 that match
var unitAssociations = new List <UnitAssociation>();
for (int i = 0; i < 3; i++)
{
unitAssociations.Add(CreateValidEntities.UnitAssociation(i + 1));
unitAssociations[i].Application = ApplicationRepository.GetNullableById(1);
unitAssociations[i].User = UserRepository.GetNullableById(2);
unitAssociations[i].Unit = UnitRepository.GetNullableById(i + 1);
}
unitAssociations[0].Unit = UnitRepository.Queryable.Last();
ControllerRecordFakes.FakeUnitAssociations(2, UnitAssociationRepository, unitAssociations); //Total of 5, 3 that match
#endregion Arrange
#region Act
var result = Controller.LoadUser("Name1", "LoginId2")
.AssertResultIs <JsonResult>();
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(JsonRequestBehavior.AllowGet, result.JsonRequestBehavior);
var result2 = (UserShowModel)result.Data;
Assert.IsNotNull(result2);
Assert.AreEqual("*****@*****.**", result2.Email);
Assert.AreEqual("FirstName2", result2.FirstName);
Assert.AreEqual("FirstName2 LastName2 (LoginId2)", result2.FullNameAndLogin);
Assert.AreEqual("LastName2", result2.LastName);
Assert.AreEqual("LoginId2", result2.Login);
Assert.AreEqual("+1 530 763 0395", result2.Phone);
#region Permissions Asserts
Assert.AreEqual(3, result2.Permissions.Count);
Assert.AreEqual(1, result2.Permissions[0].Id);
//Assert.AreEqual(null, result2.Permissions[0].ApplicationName);
Assert.AreEqual(1, result2.Permissions[0].RoleId);
Assert.AreEqual("Name1", result2.Permissions[0].RoleName);
Assert.AreEqual(2, result2.Permissions[1].Id);
//Assert.AreEqual(null, result2.Permissions[1].ApplicationName);
Assert.AreEqual(2, result2.Permissions[1].RoleId);
Assert.AreEqual("Name2", result2.Permissions[1].RoleName);
Assert.AreEqual(3, result2.Permissions[2].Id);
//Assert.AreEqual(null, result2.Permissions[2].ApplicationName);
Assert.AreEqual(5, result2.Permissions[2].RoleId);
Assert.AreEqual("Name5", result2.Permissions[2].RoleName);
#endregion Permissions Asserts
#region UnitAssociations Asserts
Assert.AreEqual(3, result2.UnitAssociations.Count);
Assert.AreEqual(1, result2.UnitAssociations[0].Id);
//Assert.AreEqual(null, result2.UnitAssociations[0].ApplicationName);
Assert.AreEqual(6, result2.UnitAssociations[0].UnitId);
Assert.AreEqual("ShortName6", result2.UnitAssociations[0].UnitName);
Assert.AreEqual(2, result2.UnitAssociations[1].Id);
//Assert.AreEqual(null, result2.UnitAssociations[1].ApplicationName);
Assert.AreEqual(2, result2.UnitAssociations[1].UnitId);
Assert.AreEqual("ShortName2", result2.UnitAssociations[1].UnitName);
Assert.AreEqual(3, result2.UnitAssociations[2].Id);
//Assert.AreEqual(null, result2.UnitAssociations[2].ApplicationName);
Assert.AreEqual(3, result2.UnitAssociations[2].UnitId);
Assert.AreEqual("ShortName3", result2.UnitAssociations[2].UnitName);
#endregion UnitAssociations Asserts
#endregion Assert
}
