backend/Gridient.Infrastructure.Authentication.Local.Tests/Features/AuthUsers/Commands/CreateUserCommandHandlerTests.cs - master - softailor/gridient

backend/Gridient.Infrastructure.Authentication.Local.Tests/Features/AuthUsers/Commands/CreateUserCommandHandlerTests.cs
229 строк10 KB
Jenkins
Auto add
18 фев 2026, 10:19
18 фев 2026, 10:191e6c4f8
using FluentAssertions;
using Gridient.Core.Models;
using Gridient.Core.Options;
using Gridient.Core.Services.Interfaces;
using Gridient.Infrastructure.Authentication.Local.Features.AuthUsers.Commands;
using Gridient.Infrastructure.Authentication.Local.Models;
using Gridient.Infrastructure.Authentication.Local.Repositories;
using Gridient.Infrastructure.Authentication.Local.Services;
using Gridient.Infrastructure.Authentication.Local.Tests.Helpers.TestDataBuilders;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Moq;
using Xunit;

namespace Gridient.Infrastructure.Authentication.Local.Tests.Features.AuthUsers.Commands
{
    public class CreateUserCommandHandlerTests
    {
        private readonly Mock<IUserService> _userServiceMock;
        private readonly Mock<IAuthUserRepository> _authUserRepositoryMock;
        private readonly Mock<IPasswordHasher> _passwordHasherMock;
        private readonly Mock<ILogger<CreateUserCommandHandler>> _loggerMock;
        private readonly RegistrationOptions _registrationOptions;
        private readonly CreateUserCommandHandler _handler;

        public CreateUserCommandHandlerTests()
        {
            _userServiceMock = new Mock<IUserService>();
            _authUserRepositoryMock = new Mock<IAuthUserRepository>();
            _passwordHasherMock = new Mock<IPasswordHasher>();
            _loggerMock = new Mock<ILogger<CreateUserCommandHandler>>();
            _registrationOptions = new RegistrationOptions { EnableAdminCreation = true };

            _handler = new CreateUserCommandHandler(
                _userServiceMock.Object,
                _authUserRepositoryMock.Object,
                _passwordHasherMock.Object,
                Microsoft.Extensions.Options.Options.Create(_registrationOptions),
                _loggerMock.Object);
        }

        #region Handle

        /// <summary>
        /// Проверяет, что Handle выбрасывает исключение, если создание пользователя администратором отключено
        /// </summary>
        [Fact]
        public async Task Handle_WhenAdminCreationDisabled_ShouldThrow()
        {
            // Arrange
            var disabledOptions = new RegistrationOptions { EnableAdminCreation = false };
            var handler = new CreateUserCommandHandler(
                _userServiceMock.Object,
                _authUserRepositoryMock.Object,
                _passwordHasherMock.Object,
                Microsoft.Extensions.Options.Options.Create(disabledOptions),
                _loggerMock.Object);
            
            var request = new CreateUserCommand(
                CoreUserTestDataBuilder.CreateUserRequest(),
                "admin");

            // Act
            Func<Task> act = () => handler.Handle(request, CancellationToken.None);

            // Assert
            await act.Should().ThrowAsync<InvalidOperationException>()
                .WithMessage("*отключено*");
        }

        /// <summary>
        /// Проверяет, что Handle выбрасывает исключение, если Core.User уже существует
        /// </summary>
        [Fact]
        public async Task Handle_WhenCoreUserExists_ShouldThrow()
        {
            // Arrange
            var request = new CreateUserCommand(
                CoreUserTestDataBuilder.CreateUserRequest(login: "existinguser"),
                "admin");
            var existingUser = CoreUserTestDataBuilder.CreateUser(login: "existinguser");
            
            _userServiceMock
                .Setup(x => x.GetByLoginAsync("existinguser", It.IsAny<CancellationToken>()))
                .ReturnsAsync(existingUser);

            // Act
            Func<Task> act = () => _handler.Handle(request, CancellationToken.None);

            // Assert
            await act.Should().ThrowAsync<InvalidOperationException>()
                .WithMessage("*уже существует*");
        }

        /// <summary>
        /// Проверяет, что Handle выбрасывает исключение, если AuthUser уже существует (при наличии пароля)
        /// </summary>
        [Fact]
        public async Task Handle_WhenAuthUserExists_ShouldThrow()
        {
            // Arrange
            var request = new CreateUserCommand(
                CoreUserTestDataBuilder.CreateUserRequest(login: "newuser", password: "password"),
                "admin");
            var existingAuthUser = AuthUserTestDataBuilder.CreateAuthUser(login: "newuser");
            
            _userServiceMock
                .Setup(x => x.GetByLoginAsync("newuser", It.IsAny<CancellationToken>()))
                .ReturnsAsync((User?)null);
            _authUserRepositoryMock
                .Setup(x => x.GetByLoginAsync("newuser", It.IsAny<CancellationToken>()))
                .ReturnsAsync(existingAuthUser);

            // Act
            Func<Task> act = () => _handler.Handle(request, CancellationToken.None);

            // Assert
            await act.Should().ThrowAsync<InvalidOperationException>()
                .WithMessage("*уже существует*");
        }

        /// <summary>
        /// Проверяет, что Handle создает пользователя без пароля (без AuthUser)
        /// </summary>
        [Fact]
        public async Task Handle_WhenNoPassword_ShouldCreateUserWithoutAuthUser()
        {
            // Arrange
            var request = new CreateUserCommand(
                CoreUserTestDataBuilder.CreateUserRequest(login: "newuser", password: ""),
                "admin");
            var userId = 123;
            
            _userServiceMock
                .Setup(x => x.GetByLoginAsync("newuser", It.IsAny<CancellationToken>()))
                .ReturnsAsync((User?)null);
            _userServiceMock
                .Setup(x => x.CreateAsync(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
                .ReturnsAsync(userId);

            // Act
            var result = await _handler.Handle(request, CancellationToken.None);

            // Assert
            result.Should().Be(userId);
            _authUserRepositoryMock.Verify(x => x.CreateAsync(It.IsAny<AuthUser>(), It.IsAny<CancellationToken>()), Times.Never);
        }

        /// <summary>
        /// Проверяет, что Handle создает пользователя с паролем (с AuthUser)
        /// </summary>
        [Fact]
        public async Task Handle_WhenPasswordProvided_ShouldCreateUserWithAuthUser()
        {
            // Arrange
            var request = new CreateUserCommand(
                CoreUserTestDataBuilder.CreateUserRequest(login: "newuser", password: "password"),
                "admin");
            var userId = 123;
            
            _userServiceMock
                .Setup(x => x.GetByLoginAsync("newuser", It.IsAny<CancellationToken>()))
                .ReturnsAsync((User?)null);
            _authUserRepositoryMock
                .Setup(x => x.GetByLoginAsync("newuser", It.IsAny<CancellationToken>()))
                .ReturnsAsync((AuthUser?)null);
            _userServiceMock
                .Setup(x => x.CreateAsync(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
                .ReturnsAsync(userId);
            _passwordHasherMock
                .Setup(x => x.HashPassword("password"))
                .Returns("hashed_password");
            _authUserRepositoryMock
                .Setup(x => x.CreateAsync(It.IsAny<AuthUser>(), It.IsAny<CancellationToken>()))
                .ReturnsAsync(userId);

            // Act
            var result = await _handler.Handle(request, CancellationToken.None);

            // Assert
            result.Should().Be(userId);
            _authUserRepositoryMock.Verify(x => x.CreateAsync(
                It.Is<AuthUser>(u => u.Id == userId && u.Login == "newuser" && u.PasswordHash == "hashed_password"),
                It.IsAny<CancellationToken>()), Times.Once);
        }

        /// <summary>
        /// Проверяет, что Handle удаляет Core.User при ошибке создания AuthUser
        /// </summary>
        [Fact]
        public async Task Handle_WhenAuthUserCreationFails_ShouldDeleteCoreUser()
        {
            // Arrange
            var request = new CreateUserCommand(
                CoreUserTestDataBuilder.CreateUserRequest(login: "newuser", password: "password"),
                "admin");
            var userId = 123;
            
            _userServiceMock
                .Setup(x => x.GetByLoginAsync("newuser", It.IsAny<CancellationToken>()))
                .ReturnsAsync((User?)null);
            _authUserRepositoryMock
                .Setup(x => x.GetByLoginAsync("newuser", It.IsAny<CancellationToken>()))
                .ReturnsAsync((AuthUser?)null);
            _userServiceMock
                .Setup(x => x.CreateAsync(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
                .ReturnsAsync(userId);
            _passwordHasherMock
                .Setup(x => x.HashPassword("password"))
                .Returns("hashed_password");
            _authUserRepositoryMock
                .Setup(x => x.CreateAsync(It.IsAny<AuthUser>(), It.IsAny<CancellationToken>()))
                .ThrowsAsync(new InvalidOperationException("AuthUser creation failed"));
            _userServiceMock
                .Setup(x => x.DeleteAsync("admin", userId, It.IsAny<CancellationToken>()))
                .Returns(Task.CompletedTask);

            // Act
            Func<Task> act = () => _handler.Handle(request, CancellationToken.None);

            // Assert
            await act.Should().ThrowAsync<InvalidOperationException>()
                .WithMessage("AuthUser creation failed");
            _userServiceMock.Verify(x => x.DeleteAsync("admin", userId, It.IsAny<CancellationToken>()), Times.Once);
        }

        #endregion
    }
}