FEAT: Updating endpoint and adding new unit tests

src/Feijuca.Keycloak.TokenManager/TokenManager.Api/Controllers/UserController.cs

@@ -67,9 +67,9 @@ public async Task<IActionResult> Login([FromRoute] string tenant, [FromBody] Log
         [ProducesResponseType(StatusCodes.Status201Created)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
-        public async Task<IActionResult> RefreshToken([FromRoute] string tenant, [FromBody] string refreshToken, CancellationToken cancellationToken)
+        public async Task<IActionResult> RefreshToken([FromRoute] string tenant, [FromBody] RefreshTokenRequest request, CancellationToken cancellationToken)
         {
-            var result = await _mediator.Send(new RefreshTokenCommand(tenant, refreshToken), cancellationToken);
+            var result = await _mediator.Send(new RefreshTokenCommand(tenant, request.RefreshToken), cancellationToken);
 
             if (result.IsSuccess)
             {

src/Feijuca.Keycloak.TokenManager/TokenManager.Application.Services/Commands/Users/RefreshTokenCommandHandler.cs

@@ -12,7 +12,12 @@ public class RefreshTokenCommandHandler(IUserRepository userRepository) : IReque
         public async Task<ResponseResult<TokenDetailsResponse>> Handle(RefreshTokenCommand request, CancellationToken cancellationToken)
         {
             var tokeDetails = await _userRepository.RefreshTokenAsync(request.Tenant, request.RefreshToken);
-            return tokeDetails.ToTokenResponse();
+            if (tokeDetails.IsSuccess)
+            {
+                return tokeDetails.ToTokenResponse();
+            }
+
+            return ResponseResult<TokenDetailsResponse>.Failure(tokeDetails.Error);
         }
     }
 }

src/Feijuca.Keycloak.TokenManager/TokenManager.Application.Services/Mappers/UserMapper.cs

@@ -7,7 +7,7 @@ namespace TokenManager.Application.Services.Mappers
     public static class UserMapper
     {
         public static User ToDomain(this AddUserRequest userRequest)
-        {            
+        {
             return new User(userRequest.Username!, userRequest.Password, userRequest.Email!, userRequest.FirstName!, userRequest.LastName!, userRequest.Attributes);
         }
 

src/Feijuca.Keycloak.TokenManager/TokenManager.Application.Services/Requests/User/LoginUserRequest.cs

@@ -1,6 +1,4 @@
-using Newtonsoft.Json;
-
-namespace TokenManager.Application.Services.Requests.User
+namespace TokenManager.Application.Services.Requests.User
 {
     public record LoginUserRequest(string Username, string Password);
 }

src/Feijuca.Keycloak.TokenManager/TokenManager.Application.Services/Requests/User/RefreshTokenRequest.cs

@@ -0,0 +1,4 @@
+namespace TokenManager.Application.Services.Requests.User
+{
+    public record RefreshTokenRequest(string RefreshToken);
+}

src/Feijuca.Keycloak.TokenManager/TokenManager.Application.Services/Responses/ResponseResult.cs

@@ -41,11 +41,6 @@ public T Result
         {
             get
             {
-                if (!IsSuccess)
-                {
-                    throw new InvalidOperationException("No value available for failure result.");
-                }
-
                 return _result;
             }
         }

src/Feijuca.Keycloak.TokenManager/TokenManager.Domain/Errors/UserErrors.cs

@@ -15,6 +15,11 @@ public static class UserErrors
             "User.InvalidUserNameOrPassword",
             $"An error occurred while trying to get JWT token. Please check username and password. {TechnicalMessage}"
         );
+
+        public static Error InvalidRefreshToken => new(
+            "User.InvalidRefreshTokenProvided",
+            $"An error occurred while trying to refresh token. {TechnicalMessage}"
+        );
 
         public static Error WrongPasswordDefinition => new(
             "User.WrongPasswordDefinition",

src/Feijuca.Keycloak.TokenManager/TokenManager.Infra.Data/Repositories/UserRepository.cs

@@ -119,7 +119,7 @@ public async Task<Result<TokenDetails>> RefreshTokenAsync(string tenant, string
 
             var responseMessage = await response.Content.ReadAsStringAsync();
             UserErrors.SetTechnicalMessage(responseMessage);
-            return Result<TokenDetails>.Failure(UserErrors.InvalidUserNameOrPasswordError);
+            return Result<TokenDetails>.Failure(UserErrors.InvalidRefreshToken);
         }
 
         public async Task<(bool result, string content)> CreateNewUserAsync(string tenant, User user)

tests/TokenManager.UnitTests/Handlers/RefreshTokenCommandHandlerTests.cs

@@ -0,0 +1,93 @@
+using AutoFixture;
+using FluentAssertions;
+using Moq;
+using TokenManager.Application.Services.Commands.Users;
+using TokenManager.Domain.Entities;
+using TokenManager.Domain.Interfaces;
+
+namespace TokenManager.UnitTests.Handlers
+{
+    public class RefreshTokenCommandHandlerTests
+    {
+        private readonly Fixture _autoFixture = new();
+        private readonly Mock<IUserRepository> _userRepositoryMock = new();
+        private readonly RefreshTokenCommandHandler _refreshTokenCommandHandler;
+
+        public RefreshTokenCommandHandlerTests()
+        {
+            _refreshTokenCommandHandler = new(_userRepositoryMock.Object);
+        }
+
+        [Fact]
+        public async Task HandleWhenInformAValidToken_ShouldBeRefreshedTheToken()
+        {
+            // Arrange
+            var refreshTokenCommand = _autoFixture.Create<RefreshTokenCommand>();
+
+            var tokenDetails = _autoFixture.Create<TokenDetails>();
+            var successResult = Result<TokenDetails>.Success(tokenDetails);
+
+            _userRepositoryMock
+                .Setup(x => x.RefreshTokenAsync(It.IsAny<string>(), It.IsAny<string>()))
+                .ReturnsAsync(successResult);
+
+            //Act
+            var resultHandle = await _refreshTokenCommandHandler.Handle(refreshTokenCommand, CancellationToken.None);
+
+            //Assert
+            resultHandle.IsSuccess
+                .Should()
+                .Be(true);
+
+            resultHandle.Result.AccessToken
+                .Should()
+                .Be(tokenDetails.Access_Token);
+
+            resultHandle.Result.ExpiresIn
+                .Should()
+                .Be(tokenDetails.Expires_In);
+
+            resultHandle.Result.RefreshExpiresIn
+                .Should()
+                .Be(tokenDetails.Refresh_Expires_In);
+
+            resultHandle.Result.RefreshToken
+                .Should()
+                .Be(tokenDetails.Refresh_Token);
+
+            resultHandle.Result.TokenType
+                .Should()
+                .Be(tokenDetails.Token_Type);
+        }
+
+        [Fact]
+        public async Task HandleWhenInformAInvalidUser_ShouldNotBeLoggedAndShouldReturnsAnError()
+        {
+            // Arrange
+            var refreshTokenCommand = _autoFixture.Create<RefreshTokenCommand>();
+
+            var error = _autoFixture.Create<Error>();
+            var failureResult = Result<TokenDetails>.Failure(error);
+
+            _userRepositoryMock
+                .Setup(x => x.RefreshTokenAsync(It.IsAny<string>(), It.IsAny<string>()))
+                .ReturnsAsync(failureResult);
+
+            //Act
+            var resultHandle = await _refreshTokenCommandHandler.Handle(refreshTokenCommand, CancellationToken.None);
+
+            //Assert
+            resultHandle.IsSuccess
+                .Should()
+                .Be(false);
+
+            resultHandle.Error.Description
+                .Should()
+                .Contain(error.Description);
+
+            resultHandle.Error.Code
+                .Should()
+                .Contain(error.Code);
+        }
+    }
+}