DocumentOrganizer/Diligent.WebAPI.Tests/Services/UserServiceTests.cs

using AutoMapper;
using Diligent.WebAPI.Business.Helper;
using Diligent.WebAPI.Business.MappingProfiles;
using Diligent.WebAPI.Business.Services;
using Diligent.WebAPI.Business.Settings;
using Diligent.WebAPI.Contracts.DTOs;
using Diligent.WebAPI.Contracts.DTOs.User;
using Diligent.WebAPI.Contracts.Exceptions;
using Diligent.WebAPI.Data;
using Diligent.WebAPI.Data.Entities;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using NSubstitute;
using NSubstitute.ReturnsExtensions;

namespace Diligent.WebAPI.Tests.Services
{
    public class UserServiceTests
    {

        private readonly List<User> _users;
        private readonly User _user;
        private readonly IMapper _mapper;
        private readonly IUserStore<User> _mockStore;
        private readonly UserManager<User> _mockUserManager;
        private readonly ILogger<UserService> _logger;


        public UserServiceTests()
        {
            _mockStore = Substitute.For<IUserStore<User>>();
            _mockUserManager = Substitute.For<UserManager<User>>(_mockStore, null, null, null, null, null, null, null, null);
            _logger = Substitute.For<ILogger<UserService>>();

            _user = new User
            {
                Id = 1,
                PasswordHash = "AQAAAAEAACcQAAAAEJnWVhD/qftzqJq5XOUD0BxEBEwhd7vS46HeDD+9cwEsqO9ev9xEORJVjmFMASUGJg==",
                FirstName = "Dzenis",
                LastName = "Dzenis",
                UserName = "dzenis",
                NormalizedUserName = "DZENIS",
                Email = "dzenis@dilig.net",
                NormalizedEmail = "DZENIS@DILIG.NET",
                EmailConfirmed = false,
                IsEnabled = true,
                AccessFailedCount = 0,
                SecurityStamp = "2D3XPK2P5MAKO377AWFU3T4ZFFYTSOJX",
                ConcurrencyStamp = "2D3XPK2P5MAKO377AWFU3T4ZFFYTSOJX",
            };

            _users = new List<User>
            {
                _user
            };

            // configure mapper
            var configuration = new MapperConfiguration(cfg => cfg.AddProfiles(
                new List<Profile>
            {
                new UserMappingProfile()
            }));

            _mapper = new Mapper(configuration);
        }


        [Fact]
        public async Task GetById_ShouldReturnUser()
        {
            _mockUserManager.FindByIdAsync(Arg.Any<string>()).Returns(_user);
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);

            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();

            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);
            var result = await service.GetById(1);
            result.Should().Be(_user);
        }

        [Fact]
        public async Task GetById_ShouldThrowExceptionIfUserNotFound()
        {
            _mockUserManager.FindByIdAsync(Arg.Any<string>()).ReturnsNull();
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);

            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();

            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);
            await Assert.ThrowsAsync<EntityNotFoundException>(() => service.GetById(15));
        }

        [Fact]
        public async Task GetByEmail_ShouldReturnUser()
        {
            _mockUserManager.FindByEmailAsync(Arg.Any<string>()).Returns(_user);
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);

            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();

            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);
            var result = await service.GetByEmail("mail");
            result.Should().Be(_user);
        }

        [Fact]
        public async Task GetByEmail_ShouldThrowExceptionIfUserNotFound()
        {
            _mockUserManager.FindByEmailAsync(Arg.Any<string>()).ReturnsNull();
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);

            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();

            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);
            await Assert.ThrowsAsync<EntityNotFoundException>(() => service.GetByEmail("someMail"));
        }
        
        // ?
        [Fact]
        public async Task GetFirst_ShouldThrowExceptionIfUsersNotFound()
        {
            _mockUserManager.Users.FirstOrDefaultAsync().ReturnsNull();
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);

            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();

            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);
            await Assert.ThrowsAsync<EntityNotFoundException>(() => service.GetFirst());
        }

        // ?
        [Fact]
        public async Task GetFirst_ShouldReturnUser()
        {
            //var userStoreStub = NSubstitute.Substitute.For<IUserStore<ApplicationUser>>();
            //var mockM = Substitute.For<UserManager<>>();
            _mockUserManager.Users.FirstOrDefault().Returns(_user);
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);

            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();

            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);
            
            var result = await service.GetFirst();
            result.Should().Be(_user);
        }
        
        [Fact]
        public async Task RemoveUser_ShouldDeleteUser()
        {
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);

            _mockUserManager.FindByIdAsync(Arg.Any<string>()).Returns(n => _user);

            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();

            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);
            await service.RemoveUser(_user);

            _mockUserManager.FindByIdAsync(Arg.Any<string>()).ReturnsNull();

            await Assert.ThrowsAsync<EntityNotFoundException>(()=>service.GetById(1));
        }

        [Fact]
        public async Task ToggleEnable_ShouldDisableUser()
        {
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);
            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();
            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);

            var result = await service.ToggleEnable(_user);
            Assert.Equal(false, result);
        }

        [Fact]
        public async Task Invite_ShouldFailIfUserExists()
        {
            _mockUserManager.FindByEmailAsync(Arg.Any<string>()).Returns(_user);
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);
            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();
            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);

            var result = await service.SendRegistrationLink(new Contracts.DTOs.User.InviteDTO
            {
                Email = "string",
                FirstName = "string",
                LastName = "string",
            });

            Assert.Equal(true, result.IsError);
        }

        [Fact]
        public async Task Invite_ShouldCallCreateAsyncIfUserDoesNotExist()
        {
            _mockUserManager.FindByEmailAsync(Arg.Any<string>()).ReturnsNull();
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users); 
            var frontSettings = Options.Create<FrontEndSettings>(new FrontEndSettings
            {
                BaseUrl = "some url"
            });
            var mailer = Substitute.For<IEmailer>();
            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);

            var result = await service.SendRegistrationLink(new Contracts.DTOs.User.InviteDTO
            {
                Email = "string@dilig.net",
                FirstName = "string",
                LastName = "string",
            });

            var newUser = new User
            {
                UserName = "string",
                Email = "string",
                FirstName = "string",
                LastName = "string",
                IsEnabled = false
            }
;
            await _mockUserManager.ReceivedWithAnyArgs(1).CreateAsync(newUser, "Something123@");
            await mailer.ReceivedWithAnyArgs(1).SendEmailAndWriteToDbAsync("string@dilig.net", "Welcome", HTMLHelper.RenderRegisterPage($"localhost/register?token=token&email=string@dilig.net"), isHtml: true);

            result.Should().BeEquivalentTo(
                new ServiceResponseDTO<object>
                {
                    Data = new { Message = "Link has been sent!" }
                }
            );
        }

        [Fact]
        public async Task CreateUser_ShouldCallCreateAsync()
        {
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);

            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();

            // mock mapper to count calls
            var mockMapper = Substitute.For<IMapper>();
            var service = new UserService(frontSettings, _mockUserManager, mockMapper, databaseContext, mailer, _logger);

            var model = new Contracts.DTOs.Auth.CreateUserRequestDto
            {
                Email = "string",
                Password = "SomePass123@",
                UserName = "string",
                FirstName = "string",
                LastName = "string",
            };

            await service.CreateUser(model);

            // real mapping to use user as argument
            var user = _mapper.Map<User>(model);

            mockMapper.ReceivedWithAnyArgs(1).Map<User>(model);
            await _mockUserManager.ReceivedWithAnyArgs(1).CreateAsync(user, "SomePass123");
        }
    }
}