Moves most of the UserRepositoryTest

src/Umbraco.Infrastructure/Persistence/Repositories/Implement/UserGroupRepository.cs

@@ -319,7 +319,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
         private void PersistAllowedSections(IUserGroup entity)
         {
-            var userGroup = (UserGroup) entity;
+            var userGroup = entity;
 
             // First delete all
             Database.Delete<UserGroup2AppDto>("WHERE UserGroupId = @UserGroupId", new { UserGroupId = userGroup.Id });

src/Umbraco.Tests.Common/Builders/UserBuilder.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Linq;
+using Moq;
+using Umbraco.Core;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Models.Membership;
+using Umbraco.Tests.Common.Builders.Interfaces;
+
+namespace Umbraco.Tests.Common.Builders
+{
+    public class UserBuilder
+        : BuilderBase<User>,
+            IWithIdBuilder
+    {
+        private int? _id;
+        private string _language;
+        private bool? _approved;
+        private string _name;
+        private string _rawPassword;
+        private bool? _isLockedOut;
+        private string _email;
+        private string _username;
+        private string _defaultLang;
+        private string _suffix = string.Empty;
+
+        public UserBuilder WithDefaultUILanguage(string defaultLang)
+        {
+            _defaultLang = defaultLang;
+            return this;
+        }
+
+        public UserBuilder WithLanguage(string language)
+        {
+            _language = language;
+            return this;
+        }
+
+        public UserBuilder WithApproved(bool approved)
+        {
+            _approved = approved;
+            return this;
+        }
+
+        public UserBuilder WithRawPassword(string rawPassword)
+        {
+            _rawPassword = rawPassword;
+            return this;
+        }
+
+        public UserBuilder WithEmail(string email)
+        {
+            _email = email;
+            return this;
+        }
+
+        public UserBuilder WithUsername(string username)
+        {
+            _username = username;
+            return this;
+        }
+
+        public UserBuilder WithLockedOut(bool isLockedOut)
+        {
+            _isLockedOut = isLockedOut;
+            return this;
+        }
+
+        public UserBuilder WithName(string name)
+        {
+            _name = name;
+            return this;
+        }
+
+        /// <summary>
+        /// Will suffix the name, email and username for testing
+        /// </summary>
+        /// <param name="suffix"></param>
+        /// <returns></returns>
+        public UserBuilder WithSuffix(string suffix)
+        {
+            _suffix = suffix;
+            return this;
+        }
+
+        public override User Build()
+        {
+            var globalSettings = Mock.Of<IGlobalSettings>(x => x.DefaultUILanguage == (_defaultLang ?? "en-US"));
+            return new User(globalSettings,
+                _name ?? "TestUser" + _suffix,
+                _email ?? "test" + _suffix + "@test.com",
+                _username ?? "TestUser" + _suffix,
+                _rawPassword ?? "abcdefghijklmnopqrstuvwxyz")
+            {
+                Language = _language ?? _defaultLang ?? "en-US",
+                IsLockedOut = _isLockedOut ?? false,
+                IsApproved = _approved ?? true
+            };
+        }
+
+        int? IWithIdBuilder.Id
+        {
+            get => _id;
+            set => _id = value;
+        }
+    }
+}

src/Umbraco.Tests.Common/Builders/UserGroupBuilder.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using System.Linq;
+using Moq;
+using Umbraco.Core.Models.Membership;
+using Umbraco.Tests.Common.Builders.Interfaces;
+
+namespace Umbraco.Tests.Common.Builders
+{
+    public class UserGroupBuilder
+        : BuilderBase<IUserGroup>,
+            IWithIdBuilder
+    {
+        private int? _startContentId;
+        private int? _startMediaId;
+        private string _alias;
+        private string _icon;
+        private string _name;
+        private IEnumerable<string> _permissions = Enumerable.Empty<string>();
+        private IEnumerable<string> _sectionCollection = Enumerable.Empty<string>();
+        private string _suffix;
+        private int? _id;
+
+        /// <summary>
+        /// Will suffix the name and alias for testing
+        /// </summary>
+        /// <param name="suffix"></param>
+        /// <returns></returns>
+        public UserGroupBuilder WithSuffix(string suffix)
+        {
+            _suffix = suffix;
+            return this;
+        }
+
+        public IReadOnlyUserGroup BuildReadOnly(IUserGroup userGroup)
+        {
+            return Mock.Of<IReadOnlyUserGroup>(x =>
+                x.Permissions == userGroup.Permissions &&
+                x.Alias == userGroup.Alias &&
+                x.Icon == userGroup.Icon &&
+                x.Name == userGroup.Name &&
+                x.StartContentId == userGroup.StartContentId &&
+                x.StartMediaId == userGroup.StartMediaId &&
+                x.AllowedSections == userGroup.AllowedSections &&
+                x.Id == userGroup.Id);
+        }
+
+        public override IUserGroup Build()
+        {
+            return Mock.Of<IUserGroup>(x =>
+                x.StartContentId == _startContentId &&
+                x.StartMediaId == _startMediaId &&
+                x.Name == (_name ?? ("TestUserGroup" + _suffix)) &&
+                x.Alias == (_alias ?? ("testUserGroup" + _suffix)) &&
+                x.Icon == _icon &&
+                x.Permissions == _permissions &&
+                x.AllowedSections == _sectionCollection);
+        }
+
+        int? IWithIdBuilder.Id
+        {
+            get => _id;
+            set => _id = value;
+        }
+    }
+}

src/Umbraco.Tests.Integration/Persistence/Repositories/UserRepositoryTest.cs

@@ -0,0 +1,393 @@
+using System.Linq;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models.Membership;
+using Umbraco.Core.Persistence.Mappers;
+using Umbraco.Core.Persistence.Repositories;
+using Umbraco.Core.Persistence.Repositories.Implement;
+using Umbraco.Core.Scoping;
+using Umbraco.Tests.Testing;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.PropertyEditors;
+using System;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Services.Implement;
+using Umbraco.Tests.Integration.Testing;
+
+namespace Umbraco.Tests.Persistence.Repositories
+{
+    [TestFixture]
+    [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest, WithApplication = true, Logger = UmbracoTestOptions.Logger.Console)]
+    public class UserRepositoryTest : UmbracoIntegrationTest
+    {
+        private UserRepository CreateRepository(IScopeProvider provider)
+        {
+            var accessor = (IScopeAccessor) provider;
+            var repository = new UserRepository(accessor, AppCaches.Disabled, Logger, Mappers, GlobalSettings, Mock.Of<IUserPasswordConfiguration>());
+            return repository;
+        }
+
+        private UserGroupRepository CreateUserGroupRepository(IScopeProvider provider)
+        {
+            var accessor = (IScopeAccessor) provider;
+            return new UserGroupRepository(accessor, AppCaches.Disabled, Logger, ShortStringHelper);
+        }
+
+        [Test]
+        public void Can_Perform_Add_On_UserRepository()
+        {
+            // Arrange
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                var user = UserBuilder.Build();
+
+                // Act
+                repository.Save(user);
+
+
+                // Assert
+                Assert.That(user.HasIdentity, Is.True);
+            }
+        }
+
+        [Test]
+        public void Can_Perform_Multiple_Adds_On_UserRepository()
+        {
+            // Arrange
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                var user1 = UserBuilder.WithSuffix("1").Build();
+                var use2 = UserBuilder.WithSuffix("2").Build();
+
+                // Act
+                repository.Save(user1);
+
+                repository.Save(use2);
+
+
+                // Assert
+                Assert.That(user1.HasIdentity, Is.True);
+                Assert.That(use2.HasIdentity, Is.True);
+            }
+        }
+
+        [Test]
+        public void Can_Verify_Fresh_Entity_Is_Not_Dirty()
+        {
+            // Arrange
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                var user = UserBuilder.Build();
+                repository.Save(user);
+
+
+                // Act
+                var resolved = repository.Get((int)user.Id);
+                bool dirty = ((User)resolved).IsDirty();
+
+                // Assert
+                Assert.That(dirty, Is.False);
+            }
+        }
+
+        [Test]
+        public void Can_Perform_Delete_On_UserRepository()
+        {
+            // Arrange
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                var user = UserBuilder.Build();
+
+                // Act
+                repository.Save(user);
+
+                var id = user.Id;
+
+                var repository2 = new UserRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, Mock.Of<IMapperCollection>(),GlobalSettings, Mock.Of<IUserPasswordConfiguration>());
+
+                repository2.Delete(user);
+
+
+                var resolved = repository2.Get((int) id);
+
+                // Assert
+                Assert.That(resolved, Is.Null);
+            }
+        }
+
+        [Test]
+        public void Can_Perform_Get_On_UserRepository()
+        {
+            // Arrange
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+                var userGroupRepository = CreateUserGroupRepository(provider);
+
+                var user = CreateAndCommitUserWithGroup(repository, userGroupRepository);
+
+                // Act
+                var updatedItem = repository.Get(user.Id);
+
+                // FIXME: this test cannot work, user has 2 sections but the way it's created,
+                // they don't show, so the comparison with updatedItem fails - fix!
+
+                // Assert
+                AssertPropertyValues(updatedItem, user);
+            }
+        }
+
+        [Test]
+        public void Can_Perform_GetByQuery_On_UserRepository()
+        {
+            // Arrange
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                CreateAndCommitMultipleUsers(repository);
+
+                // Act
+                var query = scope.SqlContext.Query<IUser>().Where(x => x.Username == "TestUser1");
+                var result = repository.Get(query);
+
+                // Assert
+                Assert.That(result.Count(), Is.GreaterThanOrEqualTo(1));
+            }
+        }
+
+        [Test]
+        public void Can_Perform_GetAll_By_Param_Ids_On_UserRepository()
+        {
+            // Arrange
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                var users = CreateAndCommitMultipleUsers(repository);
+
+                // Act
+                var result = repository.GetMany((int) users[0].Id, (int) users[1].Id);
+
+                // Assert
+                Assert.That(result, Is.Not.Null);
+                Assert.That(result.Any(), Is.True);
+                Assert.That(result.Count(), Is.EqualTo(2));
+            }
+        }
+
+        [Test]
+        public void Can_Perform_GetAll_On_UserRepository()
+        {
+            // Arrange
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                CreateAndCommitMultipleUsers(repository);
+
+                // Act
+                var result = repository.GetMany();
+
+                // Assert
+                Assert.That(result, Is.Not.Null);
+                Assert.That(result.Any(), Is.True);
+                Assert.That(result.Count(), Is.GreaterThanOrEqualTo(3));
+            }
+        }
+
+        [Test]
+        public void Can_Perform_Exists_On_UserRepository()
+        {
+            // Arrange
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                var users = CreateAndCommitMultipleUsers(repository);
+
+                // Act
+                var exists = repository.Exists(users[0].Id);
+
+                // Assert
+                Assert.That(exists, Is.True);
+            }
+        }
+
+        [Test]
+        public void Can_Perform_Count_On_UserRepository()
+        {
+            // Arrange
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                var users = CreateAndCommitMultipleUsers(repository);
+
+                // Act
+                var query = scope.SqlContext.Query<IUser>().Where(x => x.Username == "TestUser1" || x.Username == "TestUser2");
+                var result = repository.Count(query);
+
+                // Assert
+                Assert.AreEqual(2, result);
+            }
+        }
+
+        [Test]
+        public void Can_Get_Paged_Results_By_Query_And_Filter_And_Groups()
+        {
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                var users = CreateAndCommitMultipleUsers(repository);
+                var query = provider.SqlContext.Query<IUser>().Where(x => x.Username == "TestUser1" || x.Username == "TestUser2");
+
+                try
+                {
+                    scope.Database.AsUmbracoDatabase().EnableSqlTrace = true;
+                    scope.Database.AsUmbracoDatabase().EnableSqlCount = true;
+
+                    // Act
+                    var result = repository.GetPagedResultsByQuery(query, 0, 10, out var totalRecs, user => user.Id, Direction.Ascending,
+                            excludeUserGroups: new[] { Constants.Security.TranslatorGroupAlias },
+                            filter: provider.SqlContext.Query<IUser>().Where(x => x.Id > -1));
+
+                    // Assert
+                    Assert.AreEqual(2, totalRecs);
+                }
+                finally
+                {
+                    scope.Database.AsUmbracoDatabase().EnableSqlTrace = false;
+                    scope.Database.AsUmbracoDatabase().EnableSqlCount = false;
+                }
+            }
+
+        }
+
+        [Test]
+        public void Can_Get_Paged_Results_With_Filter_And_Groups()
+        {
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                var users = CreateAndCommitMultipleUsers(repository);
+
+                try
+                {
+                    scope.Database.AsUmbracoDatabase().EnableSqlTrace = true;
+                    scope.Database.AsUmbracoDatabase().EnableSqlCount = true;
+
+                    // Act
+                    var result = repository.GetPagedResultsByQuery(null, 0, 10, out var totalRecs, user => user.Id, Direction.Ascending,
+                        includeUserGroups: new[] { Constants.Security.AdminGroupAlias, Constants.Security.SensitiveDataGroupAlias },
+                        excludeUserGroups: new[] { Constants.Security.TranslatorGroupAlias },
+                        filter: provider.SqlContext.Query<IUser>().Where(x => x.Id == -1));
+
+                    // Assert
+                    Assert.AreEqual(1, totalRecs);
+                }
+                finally
+                {
+                    scope.Database.AsUmbracoDatabase().EnableSqlTrace = false;
+                    scope.Database.AsUmbracoDatabase().EnableSqlCount = false;
+                }
+            }
+        }
+
+        [Test]
+        public void Can_Invalidate_SecurityStamp_On_Username_Change()
+        {
+            // Arrange
+            var provider = ScopeProvider;
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+                var userGroupRepository = CreateUserGroupRepository(provider);
+
+                var user = CreateAndCommitUserWithGroup(repository, userGroupRepository);
+                var originalSecurityStamp = user.SecurityStamp;
+
+                // Ensure when user generated a security stamp is present
+                Assert.That(user.SecurityStamp, Is.Not.Null);
+                Assert.That(user.SecurityStamp, Is.Not.Empty);
+
+                // Update username
+                user.Username = user.Username + "UPDATED";
+                repository.Save(user);
+
+                // Get the user
+                var updatedUser = repository.Get(user.Id);
+
+                // Ensure the Security Stamp is invalidated & no longer the same
+                Assert.AreNotEqual(originalSecurityStamp, updatedUser.SecurityStamp);
+            }
+        }
+
+        private void AssertPropertyValues(IUser updatedItem, IUser originalUser)
+        {
+            Assert.That(updatedItem.Id, Is.EqualTo(originalUser.Id));
+            Assert.That(updatedItem.Name, Is.EqualTo(originalUser.Name));
+            Assert.That(updatedItem.Language, Is.EqualTo(originalUser.Language));
+            Assert.That(updatedItem.IsApproved, Is.EqualTo(originalUser.IsApproved));
+            Assert.That(updatedItem.RawPasswordValue, Is.EqualTo(originalUser.RawPasswordValue));
+            Assert.That(updatedItem.IsLockedOut, Is.EqualTo(originalUser.IsLockedOut));
+            Assert.IsTrue(updatedItem.StartContentIds.UnsortedSequenceEqual(originalUser.StartContentIds));
+            Assert.IsTrue(updatedItem.StartMediaIds.UnsortedSequenceEqual(originalUser.StartMediaIds));
+            Assert.That(updatedItem.Email, Is.EqualTo(originalUser.Email));
+            Assert.That(updatedItem.Username, Is.EqualTo(originalUser.Username));
+            Assert.That(updatedItem.AllowedSections.Count(), Is.EqualTo(originalUser.AllowedSections.Count()));
+            foreach (var allowedSection in originalUser.AllowedSections)
+                Assert.IsTrue(updatedItem.AllowedSections.Contains(allowedSection));
+        }
+
+        private User CreateAndCommitUserWithGroup(IUserRepository repository, IUserGroupRepository userGroupRepository)
+        {
+            var user = UserBuilder.Build();
+            repository.Save(user);
+
+
+            var group = UserGroupBuilder.Build();
+            userGroupRepository.AddOrUpdateGroupWithUsers(@group, new[] { user.Id });
+
+            user.AddGroup(UserGroupBuilder.BuildReadOnly(group));
+
+            return user;
+        }
+
+        private IUser[] CreateAndCommitMultipleUsers(IUserRepository repository)
+        {
+            var user1 = UserBuilder.WithSuffix("1").Build();
+            var user2 = UserBuilder.WithSuffix("2").Build();
+            var user3 = UserBuilder.WithSuffix("3").Build();
+            repository.Save(user1);
+            repository.Save(user2);
+            repository.Save(user3);
+            return new IUser[] { user1, user2, user3 };
+        }
+    }
+}

src/Umbraco.Tests.Integration/Testing/UmbracoIntegrationTest.cs

@@ -7,12 +7,17 @@ using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using NUnit.Framework;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Composing;
 using Umbraco.Core.Composing.LightInject;
 using Umbraco.Core.Configuration;
+using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.Mappers;
 using Umbraco.Core.Scoping;
+using Umbraco.Core.Strings;
+using Umbraco.Tests.Common.Builders;
 using Umbraco.Tests.Integration.Extensions;
 using Umbraco.Tests.Integration.Implementations;
 using Umbraco.Tests.Testing;
@@ -127,6 +132,8 @@ namespace Umbraco.Tests.Integration.Testing
             app.UseUmbracoCore();
         }
 
+        #region Common services
+
         /// <summary>
         /// Returns the DI container
         /// </summary>
@@ -146,5 +153,21 @@ namespace Umbraco.Tests.Integration.Testing
         /// Returns the <see cref="ILogger"/>
         /// </summary>
         protected ILogger Logger => Services.GetRequiredService<ILogger>();
+
+        protected AppCaches AppCaches => Services.GetRequiredService<AppCaches>();
+        protected IIOHelper IOHelper => Services.GetRequiredService<IIOHelper>();
+        protected IShortStringHelper ShortStringHelper => Services.GetRequiredService<IShortStringHelper>();
+        protected IGlobalSettings GlobalSettings => Services.GetRequiredService<IGlobalSettings>();
+        protected IMapperCollection Mappers => Services.GetRequiredService<IMapperCollection>();
+
+        #endregion
+
+        #region Builders
+
+        protected GlobalSettingsBuilder GlobalSettingsBuilder = new GlobalSettingsBuilder();
+        protected UserBuilder UserBuilder = new UserBuilder();
+        protected UserGroupBuilder UserGroupBuilder = new UserGroupBuilder();
+
+        #endregion
     }
 }

src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs

@@ -5,21 +5,20 @@ using Umbraco.Core;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models.Membership;
-using Umbraco.Core.Persistence.Mappers;
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Core.Persistence.Repositories.Implement;
 using Umbraco.Core.Scoping;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.TestHelpers.Entities;
 using Umbraco.Tests.Testing;
-using Umbraco.Core.Persistence;
 using Umbraco.Core.PropertyEditors;
 using System;
 using Umbraco.Core.Configuration;
 
 namespace Umbraco.Tests.Persistence.Repositories
 {
+    // TODO: Move the remaining parts to Integration tests
+
     [TestFixture]
     [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest, WithApplication = true, Logger = UmbracoTestOptions.Logger.Console)]
     public class UserRepositoryTest : TestWithDatabaseBase
@@ -78,72 +77,6 @@ namespace Umbraco.Tests.Persistence.Repositories
             return new UserGroupRepository(accessor, AppCaches.Disabled, Logger, ShortStringHelper);
         }
 
-        [Test]
-        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);
-            }
-        }
-
-        [Test]
-        public void Can_Perform_Multiple_Adds_On_UserRepository()
-        {
-            // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = provider.CreateScope())
-            {
-                var repository = CreateRepository(provider);
-
-                var user1 = MockedUser.CreateUser("1");
-                var use2 = MockedUser.CreateUser("2");
-
-                // Act
-                repository.Save(user1);
-
-                repository.Save(use2);
-
-
-                // Assert
-                Assert.That(user1.HasIdentity, Is.True);
-                Assert.That(use2.HasIdentity, Is.True);
-            }
-        }
-
-        [Test]
-        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);
-            }
-        }
-
         [Test]
         public void Can_Perform_Update_On_UserRepository()
         {
@@ -206,268 +139,6 @@ namespace Umbraco.Tests.Persistence.Repositories
             }
         }
 
-        [Test]
-        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(), Mock.Of<IUserPasswordConfiguration>());
-
-                repository2.Delete(user);
-
-
-                var resolved = repository2.Get((int) id);
-
-                // Assert
-                Assert.That(resolved, Is.Null);
-            }
-        }
-
-        [Test]
-        public void Can_Perform_Get_On_UserRepository()
-        {
-            // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = provider.CreateScope())
-            {
-                var repository = CreateRepository(provider);
-                var userGroupRepository = CreateUserGroupRepository(provider);
-
-                var user = CreateAndCommitUserWithGroup(repository, userGroupRepository);
-
-                // Act
-                var updatedItem = repository.Get(user.Id);
-
-                // FIXME: this test cannot work, user has 2 sections but the way it's created,
-                // they don't show, so the comparison with updatedItem fails - fix!
-
-                // Assert
-                AssertPropertyValues(updatedItem, user);
-            }
-        }
-
-        [Test]
-        public void Can_Perform_GetByQuery_On_UserRepository()
-        {
-            // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = provider.CreateScope())
-            {
-                var repository = CreateRepository(provider);
-
-                CreateAndCommitMultipleUsers(repository);
-
-                // Act
-                var query = scope.SqlContext.Query<IUser>().Where(x => x.Username == "TestUser1");
-                var result = repository.Get(query);
-
-                // Assert
-                Assert.That(result.Count(), Is.GreaterThanOrEqualTo(1));
-            }
-        }
-
-        [Test]
-        public void Can_Perform_GetAll_By_Param_Ids_On_UserRepository()
-        {
-            // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = provider.CreateScope())
-            {
-                var repository = CreateRepository(provider);
-
-                var users = CreateAndCommitMultipleUsers(repository);
-
-                // Act
-                var result = repository.GetMany((int) users[0].Id, (int) users[1].Id);
-
-                // Assert
-                Assert.That(result, Is.Not.Null);
-                Assert.That(result.Any(), Is.True);
-                Assert.That(result.Count(), Is.EqualTo(2));
-            }
-        }
-
-        [Test]
-        public void Can_Perform_GetAll_On_UserRepository()
-        {
-            // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = provider.CreateScope())
-            {
-                var repository = CreateRepository(provider);
-
-                CreateAndCommitMultipleUsers(repository);
-
-                // Act
-                var result = repository.GetMany();
-
-                // Assert
-                Assert.That(result, Is.Not.Null);
-                Assert.That(result.Any(), Is.True);
-                Assert.That(result.Count(), Is.GreaterThanOrEqualTo(3));
-            }
-        }
-
-        [Test]
-        public void Can_Perform_Exists_On_UserRepository()
-        {
-            // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = provider.CreateScope())
-            {
-                var repository = CreateRepository(provider);
-
-                var users = CreateAndCommitMultipleUsers(repository);
-
-                // Act
-                var exists = repository.Exists(users[0].Id);
-
-                // Assert
-                Assert.That(exists, Is.True);
-            }
-        }
-
-        [Test]
-        public void Can_Perform_Count_On_UserRepository()
-        {
-            // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = provider.CreateScope())
-            {
-                var repository = CreateRepository(provider);
-
-                var users = CreateAndCommitMultipleUsers(repository);
-
-                // Act
-                var query = scope.SqlContext.Query<IUser>().Where(x => x.Username == "TestUser1" || x.Username == "TestUser2");
-                var result = repository.Count(query);
-
-                // Assert
-                Assert.AreEqual(2, result);
-            }
-        }
-
-        [Test]
-        public void Can_Get_Paged_Results_By_Query_And_Filter_And_Groups()
-        {
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = provider.CreateScope())
-            {
-                var repository = CreateRepository(provider);
-
-                var users = CreateAndCommitMultipleUsers(repository);
-                var query = provider.SqlContext.Query<IUser>().Where(x => x.Username == "TestUser1" || x.Username == "TestUser2");
-
-                try
-                {
-                    scope.Database.AsUmbracoDatabase().EnableSqlTrace = true;
-                    scope.Database.AsUmbracoDatabase().EnableSqlCount = true;
-
-                    // Act
-                    var result = repository.GetPagedResultsByQuery(query, 0, 10, out var totalRecs, user => user.Id, Direction.Ascending,
-                            excludeUserGroups: new[] { Constants.Security.TranslatorGroupAlias },
-                            filter: provider.SqlContext.Query<IUser>().Where(x => x.Id > -1));
-
-                    // Assert
-                    Assert.AreEqual(2, totalRecs);
-                }
-                finally
-                {
-                    scope.Database.AsUmbracoDatabase().EnableSqlTrace = false;
-                    scope.Database.AsUmbracoDatabase().EnableSqlCount = false;
-                }
-            }
-
-        }
-
-        [Test]
-        public void Can_Get_Paged_Results_With_Filter_And_Groups()
-        {
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = provider.CreateScope())
-            {
-                var repository = CreateRepository(provider);
-
-                var users = CreateAndCommitMultipleUsers(repository);
-
-                try
-                {
-                    scope.Database.AsUmbracoDatabase().EnableSqlTrace = true;
-                    scope.Database.AsUmbracoDatabase().EnableSqlCount = true;
-
-                    // Act
-                    var result = repository.GetPagedResultsByQuery(null, 0, 10, out var totalRecs, user => user.Id, Direction.Ascending,
-                        includeUserGroups: new[] { Constants.Security.AdminGroupAlias, Constants.Security.SensitiveDataGroupAlias },
-                        excludeUserGroups: new[] { Constants.Security.TranslatorGroupAlias },
-                        filter: provider.SqlContext.Query<IUser>().Where(x => x.Id == -1));
-
-                    // Assert
-                    Assert.AreEqual(1, totalRecs);
-                }
-                finally
-                {
-                    scope.Database.AsUmbracoDatabase().EnableSqlTrace = false;
-                    scope.Database.AsUmbracoDatabase().EnableSqlCount = false;
-                }
-            }
-        }
-
-        [Test]
-        public void Can_Invalidate_SecurityStamp_On_Username_Change()
-        {
-            // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = provider.CreateScope())
-            {
-                var repository = CreateRepository(provider);
-                var userGroupRepository = CreateUserGroupRepository(provider);
-
-                var user = CreateAndCommitUserWithGroup(repository, userGroupRepository);
-                var originalSecurityStamp = user.SecurityStamp;
-
-                // Ensure when user generated a security stamp is present
-                Assert.That(user.SecurityStamp, Is.Not.Null);
-                Assert.That(user.SecurityStamp, Is.Not.Empty);
-
-                // Update username
-                user.Username = user.Username + "UPDATED";
-                repository.Save(user);
-
-                // Get the user
-                var updatedUser = repository.Get(user.Id);
-
-                // Ensure the Security Stamp is invalidated & no longer the same
-                Assert.AreNotEqual(originalSecurityStamp, updatedUser.SecurityStamp);
-            }
-        }
-
-        private void AssertPropertyValues(IUser updatedItem, IUser originalUser)
-        {
-            Assert.That(updatedItem.Id, Is.EqualTo(originalUser.Id));
-            Assert.That(updatedItem.Name, Is.EqualTo(originalUser.Name));
-            Assert.That(updatedItem.Language, Is.EqualTo(originalUser.Language));
-            Assert.That(updatedItem.IsApproved, Is.EqualTo(originalUser.IsApproved));
-            Assert.That(updatedItem.RawPasswordValue, Is.EqualTo(originalUser.RawPasswordValue));
-            Assert.That(updatedItem.IsLockedOut, Is.EqualTo(originalUser.IsLockedOut));
-            Assert.IsTrue(updatedItem.StartContentIds.UnsortedSequenceEqual(originalUser.StartContentIds));
-            Assert.IsTrue(updatedItem.StartMediaIds.UnsortedSequenceEqual(originalUser.StartMediaIds));
-            Assert.That(updatedItem.Email, Is.EqualTo(originalUser.Email));
-            Assert.That(updatedItem.Username, Is.EqualTo(originalUser.Username));
-            Assert.That(updatedItem.AllowedSections.Count(), Is.EqualTo(originalUser.AllowedSections.Count()));
-            foreach (var allowedSection in originalUser.AllowedSections)
-                Assert.IsTrue(updatedItem.AllowedSections.Contains(allowedSection));
-        }
 
         private static User CreateAndCommitUserWithGroup(IUserRepository repository, IUserGroupRepository userGroupRepository)
         {
@@ -483,15 +154,5 @@ namespace Umbraco.Tests.Persistence.Repositories
             return user;
         }
 
-        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 };
-        }
     }
 }

src/Umbraco.Tests/TestHelpers/TestObjects-Mocks.cs

@@ -4,24 +4,19 @@ using System.Data;
 using System.Data.Common;
 using System.Linq;
 using System.Linq.Expressions;
-using System.Web;
 using Moq;
 using Umbraco.Core;
 using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration;
-using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
-using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.SqlSyntax;
 using Umbraco.Core.Services;
 using Umbraco.Tests.Common;
 using Umbraco.Web;
 using Umbraco.Web.PublishedCache;
-using Umbraco.Web.Routing;
-using Umbraco.Web.Security;
 
 namespace Umbraco.Tests.TestHelpers
 {

src/Umbraco.Tests/Umbraco.Tests.csproj

@@ -148,6 +148,7 @@
     <Compile Include="Persistence\Mappers\MapperTestBase.cs" />
     <Compile Include="Persistence\Repositories\DocumentRepositoryTest.cs" />
     <Compile Include="Persistence\Repositories\EntityRepositoryTest.cs" />
+    <Compile Include="Persistence\Repositories\UserRepositoryTest.cs" />
     <Compile Include="UmbracoExamine\ExamineExtensions.cs" />
     <Compile Include="PropertyEditors\DataValueReferenceFactoryCollectionTests.cs" />
     <Compile Include="PublishedContent\NuCacheChildrenTests.cs" />
@@ -340,7 +341,6 @@
     <Compile Include="Persistence\Repositories\TagRepositoryTest.cs" />
     <Compile Include="Persistence\Repositories\NotificationsRepositoryTest.cs" />
     <Compile Include="Persistence\Repositories\TemplateRepositoryTest.cs" />
-    <Compile Include="Persistence\Repositories\UserRepositoryTest.cs" />
     <Compile Include="Models\Mapping\ContentWebModelMappingTests.cs" />
     <Compile Include="PropertyEditors\ImageCropperTest.cs" />
     <Compile Include="PublishedContent\PublishedContentExtensionTests.cs" />