public void Can_Perform_Delete_On_UserRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
UserTypeRepository userTypeRepository;
using (var repository = CreateRepository(unitOfWork, out userTypeRepository))
{
var user = MockedUser.CreateUser(CreateAndCommitUserType());
// Act
repository.AddOrUpdate(user);
unitOfWork.Commit();
var id = user.Id;
var repository2 = RepositoryResolver.Current.ResolveByType <IUserRepository>(unitOfWork);
repository2.Delete(user);
unitOfWork.Commit();
var resolved = repository2.Get((int)id);
// Assert
Assert.That(resolved, Is.Null);
}
}
public void Can_Perform_Add_With_Group()
{
var group = MockedUserGroup.CreateUserGroup();
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateUserGroupRepository(unitOfWork))
{
repository.AddOrUpdate(group);
unitOfWork.Commit();
}
using (var repository = CreateRepository(unitOfWork))
{
IUser user = MockedUser.CreateUser();
user.AddGroup(group.ToReadOnlyGroup());
// Act
repository.AddOrUpdate(user);
unitOfWork.Commit();
user = repository.Get(user.Id);
// Assert
Assert.That(user.HasIdentity, Is.True);
Assert.AreEqual(1, user.Groups.Count());
Assert.AreEqual(group.Alias, user.Groups.ElementAt(0).Alias);
}
}
public void Get_Users_Assigned_To_Section()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
UserTypeRepository userTypeRepository;
using (var repository = CreateRepository(unitOfWork, out userTypeRepository))
{
var user1 = MockedUser.CreateUser(CreateAndCommitUserType(), "1", "test", "media");
var user2 = MockedUser.CreateUser(CreateAndCommitUserType(), "2", "media", "settings");
var user3 = MockedUser.CreateUser(CreateAndCommitUserType(), "3", "test", "settings");
repository.AddOrUpdate(user1);
repository.AddOrUpdate(user2);
repository.AddOrUpdate(user3);
unitOfWork.Commit();
// Act
var users = repository.GetUsersAssignedToSection("test");
// Assert
Assert.AreEqual(2, users.Count());
var names = users.Select(x => x.Username).ToArray();
Assert.IsTrue(names.Contains("TestUser1"));
Assert.IsTrue(names.Contains("TestUser3"));
}
}
public void Validate_Login_Session()
{
// Arrange
var provider = TestObjects.GetScopeProvider(Logger);
var user = MockedUser.CreateUser();
using (var scope = provider.CreateScope(autoComplete: true))
{
var repository = CreateRepository(provider);
repository.Save(user);
}
using (var scope = provider.CreateScope(autoComplete: true))
{
var repository = CreateRepository(provider);
var sessionId = repository.CreateLoginSession(user.Id, "1.2.3.4");
// manually update this record to be in the past
scope.Database.Execute(SqlContext.Sql()
.Update <UserLoginDto>(u => u.Set(x => x.LoggedOutUtc, DateTime.UtcNow.AddDays(-100)))
.Where <UserLoginDto>(x => x.SessionId == sessionId));
var isValid = repository.ValidateLoginSession(user.Id, sessionId);
Assert.IsFalse(isValid);
// create a new one
sessionId = repository.CreateLoginSession(user.Id, "1.2.3.4");
isValid = repository.ValidateLoginSession(user.Id, sessionId);
Assert.IsTrue(isValid);
}
}
public void Can_Perform_Delete_On_UserRepository()
{
// Arrange
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository(provider);
var user = MockedUser.CreateUser();
// Act
repository.Save(user);
var id = user.Id;
var repository2 = new UserRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger, Mock.Of <IMapperCollection>(), TestObjects.GetGlobalSettings());
repository2.Delete(user);
var resolved = repository2.Get((int)id);
// Assert
Assert.That(resolved, Is.Null);
}
}
public void Can_Perform_Delete_On_UserRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
UserTypeRepository userTypeRepository;
using (var repository = CreateRepository(unitOfWork, out userTypeRepository))
{
var user = MockedUser.CreateUser(CreateAndCommitUserType());
// Act
repository.AddOrUpdate(user);
unitOfWork.Commit();
var id = user.Id;
using (var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax))
using (var repository2 = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, utRepo))
{
repository2.Delete(user);
unitOfWork.Commit();
var resolved = repository2.Get((int)id);
// Assert
Assert.That(resolved, Is.Null);
}
}
}
public void Count_All_Online_Users()
{
var users = MockedUser.CreateMulipleUsers(10, (i, member) => member.LastLoginDate = DateTime.Now.AddMinutes(i * -2));
ServiceContext.UserService.Save(users);
var customUser = MockedUser.CreateUser();
throw new NotImplementedException();
}
private IUser[] CreateAndCommitMultipleUsers(IUserRepository repository)
{
var user1 = MockedUser.CreateUser("1");
var user2 = MockedUser.CreateUser("2");
var user3 = MockedUser.CreateUser("3");
repository.Save(user1);
repository.Save(user2);
repository.Save(user3);
return(new IUser[] { user1, user2, user3 });
}
private IUser[] CreateAndCommitMultipleUsers(IUserRepository repository, IUnitOfWork unitOfWork)
{
var user1 = MockedUser.CreateUser(CreateAndCommitUserType(), "1");
var user2 = MockedUser.CreateUser(CreateAndCommitUserType(), "2");
var user3 = MockedUser.CreateUser(CreateAndCommitUserType(), "3");
repository.AddOrUpdate(user1);
repository.AddOrUpdate(user2);
repository.AddOrUpdate(user3);
unitOfWork.Commit();
return new IUser[] {user1, user2, user3};
}
private static User CreateAndCommitUserWithGroup(IUserRepository repository, IUserGroupRepository userGroupRepository, IDatabaseUnitOfWork unitOfWork)
{
var user = MockedUser.CreateUser();
repository.AddOrUpdate(user);
unitOfWork.Commit();
var group = MockedUserGroup.CreateUserGroup();
userGroupRepository.AddOrUpdateGroupWithUsers(@group, new[] { user.Id });
unitOfWork.Commit();
return(user);
}
public void Can_Perform_Update_On_UserRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
UserTypeRepository userTypeRepository;
using (var repository = CreateRepository(unitOfWork, out userTypeRepository))
{
var user = MockedUser.CreateUser(CreateAndCommitUserType());
repository.AddOrUpdate(user);
unitOfWork.Commit();
// Act
var resolved = repository.Get((int)user.Id);
resolved.Name = "New Name";
resolved.DefaultPermissions = "ZYX";
resolved.Language = "fr";
resolved.IsApproved = false;
resolved.Password = "******";
resolved.NoConsole = true;
resolved.StartContentId = 10;
resolved.StartMediaId = 11;
resolved.DefaultToLiveEditing = true;
resolved.Email = "*****@*****.**";
resolved.Username = "******";
resolved.RemoveAllowedSection("content");
repository.AddOrUpdate(resolved);
unitOfWork.Commit();
var updatedItem = repository.Get((int)user.Id);
// Assert
Assert.That(updatedItem.Id, Is.EqualTo(resolved.Id));
Assert.That(updatedItem.Name, Is.EqualTo(resolved.Name));
Assert.That(updatedItem.DefaultPermissions, Is.EqualTo(resolved.DefaultPermissions));
Assert.That(updatedItem.Language, Is.EqualTo(resolved.Language));
Assert.That(updatedItem.IsApproved, Is.EqualTo(resolved.IsApproved));
Assert.That(updatedItem.Password, Is.EqualTo(resolved.Password));
Assert.That(updatedItem.NoConsole, Is.EqualTo(resolved.NoConsole));
Assert.That(updatedItem.StartContentId, Is.EqualTo(resolved.StartContentId));
Assert.That(updatedItem.StartMediaId, Is.EqualTo(resolved.StartMediaId));
Assert.That(updatedItem.DefaultToLiveEditing, Is.EqualTo(resolved.DefaultToLiveEditing));
Assert.That(updatedItem.Email, Is.EqualTo(resolved.Email));
Assert.That(updatedItem.Username, Is.EqualTo(resolved.Username));
Assert.That(updatedItem.AllowedSections.Count(), Is.EqualTo(1));
Assert.IsTrue(updatedItem.AllowedSections.Contains("media"));
}
}
public void Count_All_Users()
{
var users = MockedUser.CreateMulipleUsers(10);
ServiceContext.UserService.Save(users);
var customUser = MockedUser.CreateUser();
ServiceContext.UserService.Save(customUser);
var found = ServiceContext.UserService.GetCount(MemberCountType.All);
// + 1 because of the built in admin user
Assert.AreEqual(12, found);
}
public void Can_Perform_Update_On_UserRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
UserTypeRepository userTypeRepository;
using (var repository = CreateRepository(unitOfWork, out userTypeRepository))
{
var user = MockedUser.CreateUser(CreateAndCommitUserType());
repository.AddOrUpdate(user);
unitOfWork.Commit();
// Act
var resolved = (User)repository.Get((int)user.Id);
resolved.Name = "New Name";
//the db column is not used, default permissions are taken from the user type's permissions, this is a getter only
//resolved.DefaultPermissions = "ZYX";
resolved.Language = "fr";
resolved.IsApproved = false;
resolved.RawPasswordValue = "new";
resolved.IsLockedOut = true;
resolved.StartContentId = 10;
resolved.StartMediaId = 11;
resolved.Email = "*****@*****.**";
resolved.Username = "******";
resolved.RemoveAllowedSection("content");
repository.AddOrUpdate(resolved);
unitOfWork.Commit();
var updatedItem = (User)repository.Get((int)user.Id);
// Assert
Assert.That(updatedItem.Id, Is.EqualTo(resolved.Id));
Assert.That(updatedItem.Name, Is.EqualTo(resolved.Name));
//Assert.That(updatedItem.DefaultPermissions, Is.EqualTo(resolved.DefaultPermissions));
Assert.That(updatedItem.Language, Is.EqualTo(resolved.Language));
Assert.That(updatedItem.IsApproved, Is.EqualTo(resolved.IsApproved));
Assert.That(updatedItem.RawPasswordValue, Is.EqualTo(resolved.RawPasswordValue));
Assert.That(updatedItem.IsLockedOut, Is.EqualTo(resolved.IsLockedOut));
Assert.That(updatedItem.StartContentId, Is.EqualTo(resolved.StartContentId));
Assert.That(updatedItem.StartMediaId, Is.EqualTo(resolved.StartMediaId));
Assert.That(updatedItem.Email, Is.EqualTo(resolved.Email));
Assert.That(updatedItem.Username, Is.EqualTo(resolved.Username));
Assert.That(updatedItem.AllowedSections.Count(), Is.EqualTo(1));
Assert.IsTrue(updatedItem.AllowedSections.Contains("media"));
}
}
public void Count_All_Locked_Users()
{
var users = MockedUser.CreateMulipleUsers(10, (i, member) => member.IsLockedOut = i % 2 == 0);
ServiceContext.UserService.Save(users);
var customUser = MockedUser.CreateUser();
customUser.IsLockedOut = true;
ServiceContext.UserService.Save(customUser);
var found = ServiceContext.UserService.GetCount(MemberCountType.LockedOut);
Assert.AreEqual(6, found);
}
public void Find_By_Email_Exact()
{
var users = MockedUser.CreateMulipleUsers(10);
ServiceContext.UserService.Save(users);
//include this
var customUser = MockedUser.CreateUser();
customUser.Email = "*****@*****.**";
ServiceContext.UserService.Save(customUser);
var found = ServiceContext.UserService.FindByEmail("*****@*****.**", 0, 100, out _, StringPropertyMatchType.Exact);
Assert.AreEqual(1, found.Count());
}
public void Find_By_Email_Starts_With()
{
var users = MockedUser.CreateMulipleUsers(10);
ServiceContext.UserService.Save(users);
//don't find this
var customUser = MockedUser.CreateUser();
customUser.Email = "*****@*****.**";
ServiceContext.UserService.Save(customUser);
var found = ServiceContext.UserService.FindByEmail("tes", 0, 100, out _, StringPropertyMatchType.StartsWith);
Assert.AreEqual(10, found.Count());
}
private static User CreateAndCommitUserWithGroup(IUserRepository repository, IUserGroupRepository userGroupRepository)
{
var user = MockedUser.CreateUser();
repository.Save(user);
var group = MockedUserGroup.CreateUserGroup();
userGroupRepository.AddOrUpdateGroupWithUsers(@group, new[] { user.Id });
user.AddGroup(group);
return(user);
}
public void Can_Perform_Add_On_UserRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = RepositoryResolver.Current.ResolveByType<IUserRepository>(unitOfWork);
var user = MockedUser.CreateUser(CreateAndCommitUserType());
// Act
repository.AddOrUpdate(user);
unitOfWork.Commit();
// Assert
Assert.That(user.HasIdentity, Is.True);
}
public async System.Threading.Tasks.Task GetById_Fips()
{
const int mockUserId = 1234;
var user = MockedUser.CreateUser();
await RunFipsTest("GetById", mock =>
{
mock.Setup(service => service.GetUserById(1234))
.Returns((int i) => i == mockUserId ? user : null);
}, response =>
{
var obj = JsonConvert.DeserializeObject <UserDisplay>(response.Item2);
Assert.AreEqual(user.Username, obj.Username);
Assert.AreEqual(user.Email, obj.Email);
}, new { controller = "Users", action = "GetById" }, $"Users/GetById/{mockUserId}");
}
public void Can_Perform_Get_On_UserRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = RepositoryResolver.Current.ResolveByType<IUserRepository>(unitOfWork);
var user = MockedUser.CreateUser(CreateAndCommitUserType());
repository.AddOrUpdate(user);
unitOfWork.Commit();
// Act
var updatedItem = repository.Get((int)user.Id);
// Assert
AssertPropertyValues(updatedItem, user);
}
public void Count_All_Approved_Users()
{
var users = MockedUser.CreateMulipleUsers(10, (i, member) => member.IsApproved = i % 2 == 0);
ServiceContext.UserService.Save(users);
var customUser = MockedUser.CreateUser();
customUser.IsApproved = false;
ServiceContext.UserService.Save(customUser);
var found = ServiceContext.UserService.GetCount(MemberCountType.Approved);
// + 1 because of the built in admin user
Assert.AreEqual(6, found);
}
public void Can_Verify_Fresh_Entity_Is_Not_Dirty()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = RepositoryResolver.Current.ResolveByType<IUserRepository>(unitOfWork);
var user = MockedUser.CreateUser(CreateAndCommitUserType());
repository.AddOrUpdate(user);
unitOfWork.Commit();
// Act
var resolved = repository.Get((int)user.Id);
bool dirty = ((User)resolved).IsDirty();
// Assert
Assert.That(dirty, Is.False);
}
public void Get_All_Paged_Users()
{
var userType = MockedUserType.CreateUserType();
ServiceContext.UserService.SaveUserType(userType);
var users = MockedUser.CreateUser(userType, 10);
ServiceContext.UserService.Save(users);
int totalRecs;
var found = ServiceContext.UserService.GetAll(0, 2, out totalRecs);
Assert.AreEqual(2, found.Count());
// + 1 because of the built in admin user
Assert.AreEqual(11, totalRecs);
Assert.AreEqual("admin", found.First().Username);
Assert.AreEqual("test0", found.Last().Username);
}
public void Can_Perform_Add_On_UserRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var user = MockedUser.CreateUser();
// Act
repository.AddOrUpdate(user);
unitOfWork.Commit();
// Assert
Assert.That(user.HasIdentity, Is.True);
}
}
public void Find_By_Email_Contains()
{
var userType = MockedUserType.CreateUserType();
ServiceContext.UserService.SaveUserType(userType);
var users = MockedUser.CreateUser(userType, 10);
ServiceContext.UserService.Save(users);
//include this
var customUser = MockedUser.CreateUser(userType);
customUser.Email = "*****@*****.**";
ServiceContext.UserService.Save(customUser);
int totalRecs;
var found = ServiceContext.UserService.FindByEmail("test", 0, 100, out totalRecs, StringPropertyMatchType.Contains);
Assert.AreEqual(11, found.Count());
}
public void Can_Perform_Add_On_UserRepository()
{
// Arrange
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository(provider);
var user = MockedUser.CreateUser();
// Act
repository.Save(user);
// Assert
Assert.That(user.HasIdentity, Is.True);
}
}
public void Can_Perform_Get_On_UserRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
UserTypeRepository userTypeRepository;
using (var repository = CreateRepository(unitOfWork, out userTypeRepository))
{
var user = MockedUser.CreateUser(CreateAndCommitUserType());
repository.AddOrUpdate(user);
unitOfWork.Commit();
// Act
var updatedItem = repository.Get((int)user.Id);
// Assert
AssertPropertyValues(updatedItem, user);
}
}
public void Can_Verify_Fresh_Entity_Is_Not_Dirty()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var user = MockedUser.CreateUser();
repository.AddOrUpdate(user);
unitOfWork.Commit();
// Act
var resolved = repository.Get((int)user.Id);
bool dirty = ((User)resolved).IsDirty();
// Assert
Assert.That(dirty, Is.False);
}
}
public void Default_User_Permissions_Based_On_User_Type()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax))
using (var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, utRepo))
{
// Act
var user1 = MockedUser.CreateUser(CreateAndCommitUserType(), "1", "test", "media");
repository.AddOrUpdate(user1);
unitOfWork.Commit();
// Assert
Assert.AreEqual(3, user1.DefaultPermissions.Count());
Assert.AreEqual("A", user1.DefaultPermissions.ElementAt(0));
Assert.AreEqual("B", user1.DefaultPermissions.ElementAt(1));
Assert.AreEqual("C", user1.DefaultPermissions.ElementAt(2));
}
}
public void Can_Verify_Fresh_Entity_Is_Not_Dirty()
{
// Arrange
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository(provider);
var user = MockedUser.CreateUser();
repository.Save(user);
// Act
var resolved = repository.Get((int)user.Id);
bool dirty = ((User)resolved).IsDirty();
// Assert
Assert.That(dirty, Is.False);
}
}
