backend/Gridient.Infrastructure.Authentication.Local.Tests/Features/Auth/Commands/RefreshTokenCommandHandlerTests.cs - master - softailor/gridient

backend/Gridient.Infrastructure.Authentication.Local.Tests/Features/Auth/Commands/RefreshTokenCommandHandlerTests.cs
199 строк9 KB
Jenkins
Auto add
18 фев 2026, 10:19
18 фев 2026, 10:191e6c4f8
using FluentAssertions;
using Gridient.Core.Services.Interfaces;
using Gridient.Infrastructure.Authentication.Local.Features.Auth.Commands;
using Gridient.Infrastructure.Authentication.Local.Models;
using Gridient.Infrastructure.Authentication.Local.Options;
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.Auth.Commands
{
    public class RefreshTokenCommandHandlerTests
    {
        private readonly Mock<IRefreshTokenRepository> _refreshTokenRepositoryMock;
        private readonly Mock<IUserService> _userServiceMock;
        private readonly Mock<ITokenService> _tokenServiceMock;
        private readonly Mock<IAuthUserRepository> _authUserRepositoryMock;
        private readonly Mock<ILogger<RefreshTokenCommandHandler>> _loggerMock;
        private readonly JwtOptions _jwtOptions;
        private readonly RefreshTokenCommandHandler _handler;

        public RefreshTokenCommandHandlerTests()
        {
            _refreshTokenRepositoryMock = new Mock<IRefreshTokenRepository>();
            _userServiceMock = new Mock<IUserService>();
            _tokenServiceMock = new Mock<ITokenService>();
            _authUserRepositoryMock = new Mock<IAuthUserRepository>();
            _loggerMock = new Mock<ILogger<RefreshTokenCommandHandler>>();
            _jwtOptions = JwtOptionsTestDataBuilder.CreateJwtOptions();

            _handler = new RefreshTokenCommandHandler(
                _refreshTokenRepositoryMock.Object,
                _userServiceMock.Object,
                _tokenServiceMock.Object,
                _authUserRepositoryMock.Object,
                Microsoft.Extensions.Options.Options.Create(_jwtOptions),
                _loggerMock.Object);
        }

        #region Handle

        /// <summary>
        /// Проверяет, что Handle возвращает null, если пользователь не найден по refresh token
        /// </summary>
        [Fact]
        public async Task Handle_WhenUserNotFound_ShouldReturnNull()
        {
            // Arrange
            var request = new RefreshTokenCommand("invalid_token");
            _refreshTokenRepositoryMock
                .Setup(x => x.GetUserByRefreshTokenAsync("invalid_token", It.IsAny<CancellationToken>()))
                .ReturnsAsync((AuthUser?)null);

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

            // Assert
            result.Should().BeNull();
            _refreshTokenRepositoryMock.Verify(x => x.GetUserByRefreshTokenAsync("invalid_token", It.IsAny<CancellationToken>()), Times.Once);
            _refreshTokenRepositoryMock.Verify(x => x.GetByTokenAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()), Times.Never);
        }

        /// <summary>
        /// Проверяет, что Handle возвращает null, если токен не найден
        /// </summary>
        [Fact]
        public async Task Handle_WhenTokenNotFound_ShouldReturnNull()
        {
            // Arrange
            var request = new RefreshTokenCommand("token");
            var authUser = AuthUserTestDataBuilder.CreateAuthUser(login: "testuser");
            
            _refreshTokenRepositoryMock
                .Setup(x => x.GetUserByRefreshTokenAsync("token", It.IsAny<CancellationToken>()))
                .ReturnsAsync(authUser);
            _refreshTokenRepositoryMock
                .Setup(x => x.GetByTokenAsync("token", It.IsAny<CancellationToken>()))
                .ReturnsAsync((RefreshToken?)null);

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

            // Assert
            result.Should().BeNull();
            _refreshTokenRepositoryMock.Verify(x => x.GetByTokenAsync("token", It.IsAny<CancellationToken>()), Times.Once);
        }

        /// <summary>
        /// Проверяет, что Handle возвращает null, если токен истек
        /// </summary>
        [Fact]
        public async Task Handle_WhenTokenExpired_ShouldReturnNull()
        {
            // Arrange
            var request = new RefreshTokenCommand("expired_token");
            var authUser = AuthUserTestDataBuilder.CreateAuthUser(login: "testuser");
            var expiredToken = RefreshTokenTestDataBuilder.CreateRefreshToken(
                token: "expired_token",
                expiresAt: DateTime.UtcNow.AddHours(-1));
            
            _refreshTokenRepositoryMock
                .Setup(x => x.GetUserByRefreshTokenAsync("expired_token", It.IsAny<CancellationToken>()))
                .ReturnsAsync(authUser);
            _refreshTokenRepositoryMock
                .Setup(x => x.GetByTokenAsync("expired_token", It.IsAny<CancellationToken>()))
                .ReturnsAsync(expiredToken);

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

            // Assert
            result.Should().BeNull();
        }

        /// <summary>
        /// Проверяет, что Handle возвращает null, если Core пользователь не найден
        /// </summary>
        [Fact]
        public async Task Handle_WhenCoreUserNotFound_ShouldReturnNull()
        {
            // Arrange
            var request = new RefreshTokenCommand("valid_token");
            var authUser = AuthUserTestDataBuilder.CreateAuthUser(login: "testuser");
            var validToken = RefreshTokenTestDataBuilder.CreateRefreshToken(
                token: "valid_token",
                expiresAt: DateTime.UtcNow.AddHours(1));
            
            _refreshTokenRepositoryMock
                .Setup(x => x.GetUserByRefreshTokenAsync("valid_token", It.IsAny<CancellationToken>()))
                .ReturnsAsync(authUser);
            _refreshTokenRepositoryMock
                .Setup(x => x.GetByTokenAsync("valid_token", It.IsAny<CancellationToken>()))
                .ReturnsAsync(validToken);
            _userServiceMock
                .Setup(x => x.GetByLoginAsync("testuser", It.IsAny<CancellationToken>()))
                .ReturnsAsync((Gridient.Core.Models.User?)null);

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

            // Assert
            result.Should().BeNull();
            _userServiceMock.Verify(x => x.GetByLoginAsync("testuser", It.IsAny<CancellationToken>()), Times.Once);
        }

        /// <summary>
        /// Проверяет, что Handle возвращает новые токены при успешном обновлении
        /// </summary>
        [Fact]
        public async Task Handle_WhenSuccessful_ShouldReturnNewTokens()
        {
            // Arrange
            var request = new RefreshTokenCommand("valid_token");
            var authUser = AuthUserTestDataBuilder.CreateAuthUser(login: "testuser");
            var coreUser = CoreUserTestDataBuilder.CreateUser(id: 1, login: "testuser");
            var validToken = RefreshTokenTestDataBuilder.CreateRefreshToken(
                token: "valid_token",
                expiresAt: DateTime.UtcNow.AddHours(1));
            var newAccessToken = "new_access_token";
            var newRefreshToken = "new_refresh_token";
            
            _refreshTokenRepositoryMock
                .Setup(x => x.GetUserByRefreshTokenAsync("valid_token", It.IsAny<CancellationToken>()))
                .ReturnsAsync(authUser);
            _refreshTokenRepositoryMock
                .Setup(x => x.GetByTokenAsync("valid_token", It.IsAny<CancellationToken>()))
                .ReturnsAsync(validToken);
            _userServiceMock
                .Setup(x => x.GetByLoginAsync("testuser", It.IsAny<CancellationToken>()))
                .ReturnsAsync(coreUser);
            _tokenServiceMock
                .Setup(x => x.GenerateRefreshToken(It.IsAny<List<System.Security.Claims.Claim>>(), It.IsAny<DateTime>()))
                .Returns(newRefreshToken);
            _tokenServiceMock
                .Setup(x => x.GenerateAccessToken(It.IsAny<List<System.Security.Claims.Claim>>(), It.IsAny<DateTime>()))
                .Returns(newAccessToken);

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

            // Assert
            result.Should().NotBeNull();
            result!.AccessToken.Should().Be(newAccessToken);
            result.RefreshToken.Should().Be(newRefreshToken);
            _refreshTokenRepositoryMock.Verify(x => x.SaveTokenAsync(
                "testuser",
                newRefreshToken,
                It.IsAny<DateTime>(),
                It.IsAny<DateTime>(),
                It.IsAny<CancellationToken>()), Times.Once);
        }

        #endregion
    }
}