public void Can_Perform_Delete_On_UserRepository()
        {
            // Arrange
            ICoreScopeProvider provider = ScopeProvider;

            using (ICoreScope scope = provider.CreateCoreScope())
            {
                UserRepository repository = CreateRepository(provider);

                User user = UserBuilderInstance.Build();

                // Act
                repository.Save(user);

                int id = user.Id;

                Mock <IRuntimeState> mockRuntimeState = CreateMockRuntimeState(RuntimeLevel.Run);

                var repository2 = new UserRepository((IScopeAccessor)provider, AppCaches.Disabled, LoggerFactory.CreateLogger <UserRepository>(), Mock.Of <IMapperCollection>(), Options.Create(GlobalSettings), Options.Create(new UserPasswordConfigurationSettings()), new JsonNetSerializer(), mockRuntimeState.Object);

                repository2.Delete(user);

                IUser resolved = repository2.Get((int)id);

                // Assert
                Assert.That(resolved, Is.Null);
            }
        }
    private IUser[] CreateAndCommitMultipleUsers(IUserRepository repository)
    {
        var user1 = UserBuilderInstance.WithoutIdentity().WithSuffix("1").Build();
        var user2 = UserBuilderInstance.WithoutIdentity().WithSuffix("2").Build();
        var user3 = UserBuilderInstance.WithoutIdentity().WithSuffix("3").Build();

        repository.Save(user1);
        repository.Save(user2);
        repository.Save(user3);
        return(new IUser[] { user1, user2, user3 });
    }
    private User CreateAndCommitUserWithGroup(IUserRepository repository, IUserGroupRepository userGroupRepository)
    {
        var user = UserBuilderInstance.WithoutIdentity().Build();

        repository.Save(user);

        var group = UserGroupBuilderInstance.Build();

        userGroupRepository.AddOrUpdateGroupWithUsers(group, new[] { user.Id });

        user.AddGroup(UserGroupBuilderInstance.BuildReadOnly(group));

        return(user);
    }
    public void Can_Perform_Add_On_UserRepository()
    {
        // Arrange
        ICoreScopeProvider provider = ScopeProvider;

        using (var scope = provider.CreateCoreScope())
        {
            var repository = CreateRepository(provider);

            var user = UserBuilderInstance.Build();

            // Act
            repository.Save(user);

            // Assert
            Assert.That(user.HasIdentity, Is.True);
        }
    }
    public void Can_Verify_Fresh_Entity_Is_Not_Dirty()
    {
        // Arrange
        ICoreScopeProvider provider = ScopeProvider;

        using (var scope = provider.CreateCoreScope())
        {
            var repository = CreateRepository(provider);

            var user = UserBuilderInstance.WithoutIdentity().Build();
            repository.Save(user);

            // Act
            var resolved = repository.Get(user.Id);
            var dirty    = ((User)resolved).IsDirty();

            // Assert
            Assert.That(dirty, Is.False);
        }
    }
    public void Can_Perform_Multiple_Adds_On_UserRepository()
    {
        // Arrange
        ICoreScopeProvider provider = ScopeProvider;

        using (var scope = provider.CreateCoreScope())
        {
            var repository = CreateRepository(provider);

            var user1 = UserBuilderInstance.WithSuffix("1").Build();
            var use2  = UserBuilderInstance.WithSuffix("2").Build();

            // Act
            repository.Save(user1);

            repository.Save(use2);

            // Assert
            Assert.That(user1.HasIdentity, Is.True);
            Assert.That(use2.HasIdentity, Is.True);
        }
    }