backend/Gridient.Core.Tests/Controllers/UsersControllerTests.cs - master - softailor/gridient

backend/Gridient.Core.Tests/Controllers/UsersControllerTests.cs
248 строк10 KB
Jenkins
Auto add
18 фев 2026, 10:19
18 фев 2026, 10:191e6c4f8
using FluentAssertions;
using Gridient.Core.Controllers;
using Gridient.Core.Exceptions;
using Gridient.Core.Features.Users.Commands;
using Gridient.Core.Features.Users.Queries;
using Gridient.Core.Models;
using Gridient.Core.Tests.Controllers;
using Gridient.Core.Tests.Helpers.TestDataBuilders;
using MediatR;
using Microsoft.AspNetCore.Mvc;
using Moq;
using Xunit;
using UserModel = Gridient.Core.Models.User;

namespace Gridient.Core.Tests.Controllers
{
    public class UsersControllerTests : ControllerTestBase
    {
        private readonly Mock<IMediator> _mediatorMock;
        private readonly UsersController _controller;

        public UsersControllerTests()
        {
            _mediatorMock = new Mock<IMediator>();

            _controller = new UsersController(_mediatorMock.Object);

            // Настраиваем базовый ControllerContext с авторизованным пользователем
            SetupControllerContext(_controller, "testuser");
        }

        #region UpdateUser

        /// <summary>
        /// Проверяет, что метод UpdateUser успешно обновляет пользователя, если это текущий пользователь.
        /// </summary>
        [Fact]
        public async Task UpdateUser_WhenCurrentUser_ShouldReturnOk()
        {
            // Arrange
            var request = UserServiceTestDataBuilder.UpdateUserRequest(login: "testuser");
            var cancellationToken = CancellationToken.None;

            _mediatorMock
                .Setup(x => x.Send(It.Is<UpdateUserCommand>(c => c.User == request && c.CurrentUserLogin == "testuser"), cancellationToken))
                .ReturnsAsync(Unit.Value);

            // Act
            var result = await _controller.UpdateUser(request, cancellationToken);

            // Assert
            result.Should().BeOfType<OkResult>();
            _mediatorMock.Verify(x => x.Send(It.Is<UpdateUserCommand>(c => c.User == request && c.CurrentUserLogin == "testuser"), cancellationToken), Times.Once);
        }

        /// <summary>
        /// Проверяет, что метод UpdateUser успешно обновляет пользователя, если текущий пользователь - администратор.
        /// </summary>
        [Fact]
        public async Task UpdateUser_WhenAdmin_ShouldReturnOk()
        {
            // Arrange
            var request = UserServiceTestDataBuilder.UpdateUserRequest(login: "otheruser");
            var cancellationToken = CancellationToken.None;

            _mediatorMock
                .Setup(x => x.Send(It.Is<UpdateUserCommand>(c => c.User == request && c.CurrentUserLogin == "testuser"), cancellationToken))
                .ReturnsAsync(Unit.Value);

            // Act
            var result = await _controller.UpdateUser(request, cancellationToken);

            // Assert
            result.Should().BeOfType<OkResult>();
            _mediatorMock.Verify(x => x.Send(It.Is<UpdateUserCommand>(c => c.User == request && c.CurrentUserLogin == "testuser"), cancellationToken), Times.Once);
        }

        /// <summary>
        /// Проверяет, что метод UpdateUser выбрасывает ForbiddenOperationException, если нет прав (через AuthorizationBehavior).
        /// </summary>
        [Fact]
        public async Task UpdateUser_WhenNoAccess_ShouldThrowForbiddenOperationException()
        {
            // Arrange
            var request = UserServiceTestDataBuilder.UpdateUserRequest(login: "otheruser");
            var cancellationToken = CancellationToken.None;

            _mediatorMock
                .Setup(x => x.Send(It.Is<UpdateUserCommand>(c => c.User == request && c.CurrentUserLogin == "testuser"), cancellationToken))
                .ThrowsAsync(new Gridient.Core.Authorization.Exceptions.ForbiddenOperationException("Операция 'update' над пользователем otheruser запрещена"));

            // Act
            Func<Task> act = async () => await _controller.UpdateUser(request, cancellationToken);

            // Assert
            await act.Should().ThrowAsync<Gridient.Core.Authorization.Exceptions.ForbiddenOperationException>()
                .WithMessage("*запрещена*");
            _mediatorMock.Verify(x => x.Send(It.Is<UpdateUserCommand>(c => c.User == request && c.CurrentUserLogin == "testuser"), cancellationToken), Times.Once);
        }

        #endregion

        #region GetUsers

        /// <summary>
        /// Проверяет, что метод GetUsers возвращает всех пользователей.
        /// </summary>
        [Fact]
        public async Task GetUsers_ShouldReturnOkWithUsers()
        {
            // Arrange
            var cancellationToken = CancellationToken.None;
            var expectedUsers = new[]
            {
                UserServiceTestDataBuilder.CreateUser(id: 1, login: "user1"),
                UserServiceTestDataBuilder.CreateUser(id: 2, login: "user2")
            };

            _mediatorMock
                .Setup(x => x.Send(It.IsAny<GetUsersQuery>(), cancellationToken))
                .ReturnsAsync(expectedUsers);

            // Act
            var result = await _controller.GetUsers(cancellationToken);

            // Assert
            result.Should().BeOfType<OkObjectResult>();
            var okResult = result as OkObjectResult;
            okResult!.Value.Should().BeEquivalentTo(expectedUsers);
            _mediatorMock.Verify(x => x.Send(It.IsAny<GetUsersQuery>(), cancellationToken), Times.Once);
        }

        #endregion

        #region GetUserById

        /// <summary>
        /// Проверяет, что метод GetUserById возвращает пользователя по ID.
        /// </summary>
        [Fact]
        public async Task GetUserById_WithValidId_ShouldReturnOkWithUser()
        {
            // Arrange
            var userId = 1;
            var cancellationToken = CancellationToken.None;
            var expectedUser = UserServiceTestDataBuilder.CreateUser(id: userId, login: "user1");

            _mediatorMock
                .Setup(x => x.Send(It.Is<GetUserByIdQuery>(q => q.UserId == userId), cancellationToken))
                .ReturnsAsync(expectedUser);

            // Act
            var result = await _controller.GetUserById(userId, cancellationToken);

            // Assert
            result.Should().BeOfType<OkObjectResult>();
            var okResult = result as OkObjectResult;
            okResult!.Value.Should().BeEquivalentTo(expectedUser);
            _mediatorMock.Verify(x => x.Send(It.Is<GetUserByIdQuery>(q => q.UserId == userId), cancellationToken), Times.Once);
        }

        #endregion

        #region GetCurrentUser

        /// <summary>
        /// Проверяет, что метод GetCurrentUser возвращает пользователя, если он найден.
        /// </summary>
        [Fact]
        public async Task GetCurrentUser_WhenUserExists_ShouldReturnOkWithUser()
        {
            // Arrange
            var cancellationToken = CancellationToken.None;
            var expectedUser = UserServiceTestDataBuilder.CreateUser(login: "testuser");

            _mediatorMock
                .Setup(x => x.Send(It.Is<GetCurrentUserQuery>(q => q.UserLogin == "testuser"), cancellationToken))
                .ReturnsAsync(expectedUser);

            // Act
            var result = await _controller.GetCurrentUser(cancellationToken);

            // Assert
            result.Should().BeOfType<OkObjectResult>();
            var okResult = result as OkObjectResult;
            okResult!.Value.Should().BeEquivalentTo(expectedUser);
            _mediatorMock.Verify(x => x.Send(It.Is<GetCurrentUserQuery>(q => q.UserLogin == "testuser"), cancellationToken), Times.Once);
        }

        /// <summary>
        /// Проверяет, что метод GetCurrentUser возвращает NotFound, если пользователь не найден.
        /// </summary>
        [Fact]
        public async Task GetCurrentUser_WhenUserNotFound_ShouldReturnNotFound()
        {
            // Arrange
            var cancellationToken = CancellationToken.None;

            _mediatorMock
                .Setup(x => x.Send(It.Is<GetCurrentUserQuery>(q => q.UserLogin == "testuser"), cancellationToken))
                .ReturnsAsync((User?)null);

            // Act
            var result = await _controller.GetCurrentUser(cancellationToken);

            // Assert
            result.Should().BeOfType<NotFoundObjectResult>();
            var notFoundResult = result as NotFoundObjectResult;
            notFoundResult!.Value.Should().Be("Пользователь не найден");
            _mediatorMock.Verify(x => x.Send(It.Is<GetCurrentUserQuery>(q => q.UserLogin == "testuser"), cancellationToken), Times.Once);
        }

        #endregion

        #region GetEmployees

        /// <summary>
        /// Проверяет, что метод GetEmployees возвращает список пользователей.
        /// </summary>
        [Fact]
        public async Task GetEmployees_WithSearchText_ShouldReturnOkWithUsers()
        {
            // Arrange
            var searchText = "test";
            var cancellationToken = CancellationToken.None;
            var expectedUsers = new[]
            {
                UserServiceTestDataBuilder.CreateUser(id: 1, login: "testuser1"),
                UserServiceTestDataBuilder.CreateUser(id: 2, login: "testuser2")
            };

            _mediatorMock
                .Setup(x => x.Send(It.Is<GetEmployeesQuery>(q => q.SearchText == searchText), cancellationToken))
                .ReturnsAsync(expectedUsers);

            // Act
            var result = await _controller.GetEmployees(searchText, cancellationToken);

            // Assert
            result.Should().BeOfType<OkObjectResult>();
            var okResult = result as OkObjectResult;
            okResult!.Value.Should().BeEquivalentTo(expectedUsers);
            _mediatorMock.Verify(x => x.Send(It.Is<GetEmployeesQuery>(q => q.SearchText == searchText), cancellationToken), Times.Once);
        }

        #endregion
    }
}