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 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 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 async void GetPagedUsers_10()
{
var runner = new TestRunner((message, helper) =>
{
//setup some mocks
var userServiceMock = Mock.Get(helper.UmbracoContext.Application.Services.UserService);
var users = MockedUser.CreateMulipleUsers(10);
long outVal = 10;
userServiceMock.Setup(service => service.GetAll(
It.IsAny <long>(), It.IsAny <int>(), out outVal, It.IsAny <string>(), It.IsAny <Direction>(),
It.IsAny <UserState[]>(), It.IsAny <string[]>(), It.IsAny <string[]>(), It.IsAny <IQuery <IUser> >()))
.Returns(() => users);
//we need to manually apply automapper mappings with the mocked applicationcontext
InitializeMappers(helper.UmbracoContext.Application);
return(new UsersController(helper.UmbracoContext));
});
var response = await runner.Execute("Users", "GetPagedUsers", HttpMethod.Get);
var obj = JsonConvert.DeserializeObject <PagedResult <UserDisplay> >(response.Item2);
Assert.AreEqual(10, obj.TotalItems);
Assert.AreEqual(10, obj.Items.Count());
}
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 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 async System.Threading.Tasks.Task GetPagedUsers_10()
{
ApiController Factory(HttpRequestMessage message, UmbracoHelper helper)
{
//setup some mocks
var userServiceMock = Mock.Get(Current.Services.UserService);
var users = MockedUser.CreateMulipleUsers(10);
long outVal = 10;
userServiceMock.Setup(service => service.GetAll(
It.IsAny <long>(), It.IsAny <int>(), out outVal, It.IsAny <string>(), It.IsAny <Direction>(),
It.IsAny <UserState[]>(), It.IsAny <string[]>(), It.IsAny <string[]>(), It.IsAny <IQuery <IUser> >()))
.Returns(() => users);
var usersController = new UsersController();
return(usersController);
}
MockForGetPagedUsers();
var runner = new TestRunner(Factory);
var response = await runner.Execute("Users", "GetPagedUsers", HttpMethod.Get);
var obj = JsonConvert.DeserializeObject <PagedResult <UserDisplay> >(response.Item2);
Assert.AreEqual(10, obj.TotalItems);
Assert.AreEqual(10, obj.Items.Count());
}
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 Get_All_Paged_Users_For_Group_With_Filter()
{
var userGroup = MockedUserGroup.CreateUserGroup();
ServiceContext.UserService.Save(userGroup);
var users = MockedUser.CreateMulipleUsers(10).ToArray();
for (var i = 0; i < 10;)
{
users[i].AddGroup(userGroup.ToReadOnlyGroup());
i = i + 2;
}
for (var i = 0; i < 10;)
{
users[i].Name = "blah" + users[i].Name;
i = i + 3;
}
ServiceContext.UserService.Save(users);
long totalRecs;
var found = ServiceContext.UserService.GetAll(0, 2, out totalRecs, "username", Direction.Ascending, userGroups: new[] { userGroup.Alias }, filter: "blah");
Assert.AreEqual(2, found.Count());
Assert.AreEqual(2, totalRecs);
Assert.AreEqual("test0", found.First().Username);
Assert.AreEqual("test6", found.Last().Username);
}
public void Init()
{
_companyService = new Mock <ICompanyService>();
_controller = new Mock <CompaniesController>(MockedUser.GetUserManager(mockedUserId).Object, _companyService.Object)
{
CallBase = true
};
}
public void When_invalid_role_HasValidRole_returns_False()
{
var knownInvalidRole = Guid.Empty.ToString("n");
var user = MockedUser.Setup(knownInvalidRole);
var actualResult = Roles.HasValidRole(user);
Assert.That(actualResult, Is.False);
}
public void When_valid_role__HasValidRole_returns_True()
{
var knownValidRole = Roles.RoatpAssessorTeam;
var user = MockedUser.Setup(knownValidRole);
var actualResult = Roles.HasValidRole(user);
Assert.That(actualResult, Is.True);
}
public void Username_WhenTryingToAssingInvalidUserName_ShouldThrowArgumentException(string invalidUsername)
{
// arrange
string username = "******";
var user = new MockedUser(username);
// act and assert
Assert.Throws <ArgumentException>(() => user.Username = invalidUsername);
}
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();
}
public void Init()
{
_sprintService = new Mock <ISprintService>();
_controller = new Mock <SprintsController>(
MockedUser.GetUserManager(mockedUserId).Object,
_sprintService.Object
)
{
CallBase = true
};
}
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 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 });
}
public void Username_WhenAssigningValidUsername_ShouldNotThrowException()
{
// arrange
string assigningValidName = "newValidName";
string username = "******";
var user = new MockedUser(username);
// act and assert
Assert.DoesNotThrow(() => user.Username = assigningValidName);
}
public void Constructor_WhenPassedValidParameters_ShouldAssingParametersCorrectly()
{
// arrange
string username = "******";
// act
var user = new MockedUser(username);
// assert
Assert.AreEqual(user.Username, username);
}
private static Mock <IHttpContextAccessor> SetupMockedHttpContextAccessor()
{
var user = MockedUser.Setup();
var mockHttpContextAccessor = new Mock <IHttpContextAccessor>();
var context = new DefaultHttpContext {
User = user
};
mockHttpContextAccessor.Setup(_ => _.HttpContext).Returns(context);
return(mockHttpContextAccessor);
}
public void Get_All_Paged_Users_With_Filter()
{
var users = MockedUser.CreateMulipleUsers(10).ToArray();
ServiceContext.UserService.Save(users);
var found = ServiceContext.UserService.GetAll(0, 2, out var totalRecs, "username", Direction.Ascending, filter: "test");
Assert.AreEqual(2, found.Count());
Assert.AreEqual(10, totalRecs);
Assert.AreEqual("test0", found.First().Username);
Assert.AreEqual("test1", found.Last().Username);
}
public void Username_WhenAssigningValidUsername_ShouldAssingNewValueCorrectly()
{
// arrange
string assigningValidName = "newValidName";
string username = "******";
var user = new MockedUser(username);
// act
user.Username = assigningValidName;
// assert
Assert.AreEqual(user.Username, assigningValidName);
}
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 Get_All_Paged_Users()
{
var users = MockedUser.CreateMulipleUsers(10);
ServiceContext.UserService.Save(users);
var found = ServiceContext.UserService.GetAll(0, 2, out var 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_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 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());
}
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 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);
}
