Format ./web/backend/Features/Features.Auth.Tests

2026-07-16 17:47:22 +00:00 · 2026-06-20 15:09:41 -04:00
parent 2bdd7bb0c0
commit 4de455f34d
10 changed files with 389 additions and 202 deletions
--- a/web/backend/Features/Features.Auth.Tests/Commands/ConfirmUserHandlerTests.cs
+++ b/web/backend/Features/Features.Auth.Tests/Commands/ConfirmUserHandlerTests.cs
@@ -30,7 +30,7 @@ public class ConfirmUserHandlerTests
        {
            new Claim(JwtRegisteredClaimNames.Sub, userId.ToString()),
            new Claim(JwtRegisteredClaimNames.UniqueName, username),
-            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
+            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
        };
        ClaimsPrincipal principal = new(new ClaimsIdentity(claims));
        return new ValidatedToken(userId, username, principal);
@@ -46,10 +46,15 @@ public class ConfirmUserHandlerTests
        ValidatedToken validatedToken = MakeValidatedToken(userId, username);
        UserAccount userAccount = new() { UserAccountId = userId, Username = username };

-        _tokenServiceMock.Setup(x => x.ValidateConfirmationTokenAsync(confirmationToken)).ReturnsAsync(validatedToken);
+        _tokenServiceMock
+            .Setup(x => x.ValidateConfirmationTokenAsync(confirmationToken))
+            .ReturnsAsync(validatedToken);
        _authRepositoryMock.Setup(x => x.ConfirmUserAccountAsync(userId)).ReturnsAsync(userAccount);

-        ConfirmationPayload result = await _handler.Handle(new ConfirmUserCommand(confirmationToken), CancellationToken.None);
+        ConfirmationPayload result = await _handler.Handle(
+            new ConfirmUserCommand(confirmationToken),
+            CancellationToken.None
+        );

        result.Should().NotBeNull();
        result.UserAccountId.Should().Be(userId);
@@ -64,7 +69,8 @@ public class ConfirmUserHandlerTests
            .Setup(x => x.ValidateConfirmationTokenAsync(invalidToken))
            .ThrowsAsync(new UnauthorizedException("Invalid confirmation token"));

-        Func<Task<ConfirmationPayload>> act = async () => await _handler.Handle(new ConfirmUserCommand(invalidToken), CancellationToken.None);
+        Func<Task<ConfirmationPayload>> act = async () =>
+            await _handler.Handle(new ConfirmUserCommand(invalidToken), CancellationToken.None);

        await act.Should().ThrowAsync<UnauthorizedException>();
    }
@@ -79,10 +85,18 @@ public class ConfirmUserHandlerTests
        _tokenServiceMock
            .Setup(x => x.ValidateConfirmationTokenAsync(confirmationToken))
            .ReturnsAsync(MakeValidatedToken(userId, username));
-        _authRepositoryMock.Setup(x => x.ConfirmUserAccountAsync(userId)).ReturnsAsync((UserAccount?)null);
+        _authRepositoryMock
+            .Setup(x => x.ConfirmUserAccountAsync(userId))
+            .ReturnsAsync((UserAccount?)null);

-        Func<Task<ConfirmationPayload>> act = async () => await _handler.Handle(new ConfirmUserCommand(confirmationToken), CancellationToken.None);
+        Func<Task<ConfirmationPayload>> act = async () =>
+            await _handler.Handle(
+                new ConfirmUserCommand(confirmationToken),
+                CancellationToken.None
+            );

-        await act.Should().ThrowAsync<UnauthorizedException>().WithMessage("*User account not found*");
+        await act.Should()
+            .ThrowAsync<UnauthorizedException>()
+            .WithMessage("*User account not found*");
    }
-}
+}
--- a/web/backend/Features/Features.Auth.Tests/Commands/RefreshTokenHandlerTests.cs
+++ b/web/backend/Features/Features.Auth.Tests/Commands/RefreshTokenHandlerTests.cs
@@ -21,11 +21,14 @@ public class RefreshTokenHandlerTests
            .Setup(x => x.RefreshTokenAsync("old-refresh-token"))
            .ReturnsAsync(new RefreshTokenResult(user, "new-refresh-token", "new-access-token"));

-        LoginPayload result = await handler.Handle(new RefreshTokenCommand("old-refresh-token"), CancellationToken.None);
+        LoginPayload result = await handler.Handle(
+            new RefreshTokenCommand("old-refresh-token"),
+            CancellationToken.None
+        );

        result.UserAccountId.Should().Be(userId);
        result.Username.Should().Be("testuser");
        result.RefreshToken.Should().Be("new-refresh-token");
        result.AccessToken.Should().Be("new-access-token");
    }
-}
+}
--- a/web/backend/Features/Features.Auth.Tests/Commands/RegisterUserHandlerTests.cs
+++ b/web/backend/Features/Features.Auth.Tests/Commands/RegisterUserHandlerTests.cs
@@ -35,9 +35,19 @@ public class RegisterUserHandlerTests
        );
    }

-    private static RegisterUserCommand ValidCommand(string username = "newuser", string email = "john.doe@example.com")
+    private static RegisterUserCommand ValidCommand(
+        string username = "newuser",
+        string email = "john.doe@example.com"
+    )
    {
-        return new RegisterUserCommand(username, "John", "Doe", email, new DateTime(1990, 1, 1), "SecurePassword123!");
+        return new RegisterUserCommand(
+            username,
+            "John",
+            "Doe",
+            email,
+            new DateTime(1990, 1, 1),
+            "SecurePassword123!"
+        );
    }

    [Fact]
@@ -47,27 +57,46 @@ public class RegisterUserHandlerTests
        const string hashedPassword = "hashed_password_value";
        Guid expectedUserId = Guid.NewGuid();

-        _authRepoMock.Setup(x => x.GetUserByUsernameAsync(command.Username)).ReturnsAsync((UserAccount?)null);
-        _authRepoMock.Setup(x => x.GetUserByEmailAsync(command.Email)).ReturnsAsync((UserAccount?)null);
+        _authRepoMock
+            .Setup(x => x.GetUserByUsernameAsync(command.Username))
+            .ReturnsAsync((UserAccount?)null);
+        _authRepoMock
+            .Setup(x => x.GetUserByEmailAsync(command.Email))
+            .ReturnsAsync((UserAccount?)null);
        _passwordInfraMock.Setup(x => x.Hash(command.Password)).Returns(hashedPassword);

        _authRepoMock
-            .Setup(x => x.RegisterUserAsync(command.Username, command.FirstName, command.LastName, command.Email,
-                command.DateOfBirth, hashedPassword))
-            .ReturnsAsync(new UserAccount
-            {
-                UserAccountId = expectedUserId,
-                Username = command.Username,
-                FirstName = command.FirstName,
-                LastName = command.LastName,
-                Email = command.Email,
-                DateOfBirth = command.DateOfBirth,
-                CreatedAt = DateTime.UtcNow
-            });
+            .Setup(x =>
+                x.RegisterUserAsync(
+                    command.Username,
+                    command.FirstName,
+                    command.LastName,
+                    command.Email,
+                    command.DateOfBirth,
+                    hashedPassword
+                )
+            )
+            .ReturnsAsync(
+                new UserAccount
+                {
+                    UserAccountId = expectedUserId,
+                    Username = command.Username,
+                    FirstName = command.FirstName,
+                    LastName = command.LastName,
+                    Email = command.Email,
+                    DateOfBirth = command.DateOfBirth,
+                    CreatedAt = DateTime.UtcNow,
+                }
+            );

-        _tokenServiceMock.Setup(x => x.GenerateAccessToken(It.IsAny<UserAccount>())).Returns("access-token");
-        _tokenServiceMock.Setup(x => x.GenerateRefreshToken(It.IsAny<UserAccount>())).Returns("refresh-token");
-        _tokenServiceMock.Setup(x => x.GenerateConfirmationToken(It.IsAny<UserAccount>()))
+        _tokenServiceMock
+            .Setup(x => x.GenerateAccessToken(It.IsAny<UserAccount>()))
+            .Returns("access-token");
+        _tokenServiceMock
+            .Setup(x => x.GenerateRefreshToken(It.IsAny<UserAccount>()))
+            .Returns("refresh-token");
+        _tokenServiceMock
+            .Setup(x => x.GenerateConfirmationToken(It.IsAny<UserAccount>()))
            .Returns("confirmation-token");

        RegistrationPayload result = await _handler.Handle(command, CancellationToken.None);
@@ -89,18 +118,36 @@ public class RegisterUserHandlerTests
    public async Task Handle_WithExistingUsername_ThrowsConflictException()
    {
        RegisterUserCommand command = ValidCommand("existinguser");
-        UserAccount existingUser = new() { UserAccountId = Guid.NewGuid(), Username = "existinguser" };
+        UserAccount existingUser = new()
+        {
+            UserAccountId = Guid.NewGuid(),
+            Username = "existinguser",
+        };

-        _authRepoMock.Setup(x => x.GetUserByUsernameAsync(command.Username)).ReturnsAsync(existingUser);
-        _authRepoMock.Setup(x => x.GetUserByEmailAsync(command.Email)).ReturnsAsync((UserAccount?)null);
+        _authRepoMock
+            .Setup(x => x.GetUserByUsernameAsync(command.Username))
+            .ReturnsAsync(existingUser);
+        _authRepoMock
+            .Setup(x => x.GetUserByEmailAsync(command.Email))
+            .ReturnsAsync((UserAccount?)null);

-        Func<Task<RegistrationPayload>> act = async () => await _handler.Handle(command, CancellationToken.None);
+        Func<Task<RegistrationPayload>> act = async () =>
+            await _handler.Handle(command, CancellationToken.None);

-        await act.Should().ThrowAsync<ConflictException>().WithMessage("Username or email already exists");
+        await act.Should()
+            .ThrowAsync<ConflictException>()
+            .WithMessage("Username or email already exists");

        _authRepoMock.Verify(
-            x => x.RegisterUserAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),
-                It.IsAny<DateTime>(), It.IsAny<string>()),
+            x =>
+                x.RegisterUserAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<DateTime>(),
+                    It.IsAny<string>()
+                ),
            Times.Never
        );
    }
@@ -109,14 +156,23 @@ public class RegisterUserHandlerTests
    public async Task Handle_WithExistingEmail_ThrowsConflictException()
    {
        RegisterUserCommand command = ValidCommand(email: "existing@example.com");
-        UserAccount existingUser = new() { UserAccountId = Guid.NewGuid(), Email = "existing@example.com" };
+        UserAccount existingUser = new()
+        {
+            UserAccountId = Guid.NewGuid(),
+            Email = "existing@example.com",
+        };

-        _authRepoMock.Setup(x => x.GetUserByUsernameAsync(command.Username)).ReturnsAsync((UserAccount?)null);
+        _authRepoMock
+            .Setup(x => x.GetUserByUsernameAsync(command.Username))
+            .ReturnsAsync((UserAccount?)null);
        _authRepoMock.Setup(x => x.GetUserByEmailAsync(command.Email)).ReturnsAsync(existingUser);

-        Func<Task<RegistrationPayload>> act = async () => await _handler.Handle(command, CancellationToken.None);
+        Func<Task<RegistrationPayload>> act = async () =>
+            await _handler.Handle(command, CancellationToken.None);

-        await act.Should().ThrowAsync<ConflictException>().WithMessage("Username or email already exists");
+        await act.Should()
+            .ThrowAsync<ConflictException>()
+            .WithMessage("Username or email already exists");
    }

    [Fact]
@@ -125,24 +181,47 @@ public class RegisterUserHandlerTests
        RegisterUserCommand command = ValidCommand();
        const string hashedPassword = "hashed_secure_password";

-        _authRepoMock.Setup(x => x.GetUserByUsernameAsync(It.IsAny<string>())).ReturnsAsync((UserAccount?)null);
-        _authRepoMock.Setup(x => x.GetUserByEmailAsync(It.IsAny<string>())).ReturnsAsync((UserAccount?)null);
+        _authRepoMock
+            .Setup(x => x.GetUserByUsernameAsync(It.IsAny<string>()))
+            .ReturnsAsync((UserAccount?)null);
+        _authRepoMock
+            .Setup(x => x.GetUserByEmailAsync(It.IsAny<string>()))
+            .ReturnsAsync((UserAccount?)null);
        _passwordInfraMock.Setup(x => x.Hash(command.Password)).Returns(hashedPassword);

        _authRepoMock
-            .Setup(x => x.RegisterUserAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),
-                It.IsAny<string>(), It.IsAny<DateTime>(), hashedPassword))
+            .Setup(x =>
+                x.RegisterUserAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<DateTime>(),
+                    hashedPassword
+                )
+            )
            .ReturnsAsync(new UserAccount { UserAccountId = Guid.NewGuid() });

-        _tokenServiceMock.Setup(x => x.GenerateAccessToken(It.IsAny<UserAccount>())).Returns("access-token");
-        _tokenServiceMock.Setup(x => x.GenerateRefreshToken(It.IsAny<UserAccount>())).Returns("refresh-token");
+        _tokenServiceMock
+            .Setup(x => x.GenerateAccessToken(It.IsAny<UserAccount>()))
+            .Returns("access-token");
+        _tokenServiceMock
+            .Setup(x => x.GenerateRefreshToken(It.IsAny<UserAccount>()))
+            .Returns("refresh-token");

        await _handler.Handle(command, CancellationToken.None);

        _passwordInfraMock.Verify(x => x.Hash(command.Password), Times.Once);
        _authRepoMock.Verify(
-            x => x.RegisterUserAsync(command.Username, command.FirstName, command.LastName, command.Email,
-                command.DateOfBirth, hashedPassword),
+            x =>
+                x.RegisterUserAsync(
+                    command.Username,
+                    command.FirstName,
+                    command.LastName,
+                    command.Email,
+                    command.DateOfBirth,
+                    hashedPassword
+                ),
            Times.Once
        );
    }
@@ -152,19 +231,43 @@ public class RegisterUserHandlerTests
    {
        RegisterUserCommand command = ValidCommand();

-        _authRepoMock.Setup(x => x.GetUserByUsernameAsync(It.IsAny<string>())).ReturnsAsync((UserAccount?)null);
-        _authRepoMock.Setup(x => x.GetUserByEmailAsync(It.IsAny<string>())).ReturnsAsync((UserAccount?)null);
+        _authRepoMock
+            .Setup(x => x.GetUserByUsernameAsync(It.IsAny<string>()))
+            .ReturnsAsync((UserAccount?)null);
+        _authRepoMock
+            .Setup(x => x.GetUserByEmailAsync(It.IsAny<string>()))
+            .ReturnsAsync((UserAccount?)null);
        _passwordInfraMock.Setup(x => x.Hash(It.IsAny<string>())).Returns("hashed");
        _authRepoMock
-            .Setup(x => x.RegisterUserAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),
-                It.IsAny<string>(), It.IsAny<DateTime>(), It.IsAny<string>()))
-            .ReturnsAsync(new UserAccount
-                { UserAccountId = Guid.NewGuid(), Username = command.Username, Email = command.Email });
+            .Setup(x =>
+                x.RegisterUserAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<DateTime>(),
+                    It.IsAny<string>()
+                )
+            )
+            .ReturnsAsync(
+                new UserAccount
+                {
+                    UserAccountId = Guid.NewGuid(),
+                    Username = command.Username,
+                    Email = command.Email,
+                }
+            );

-        _tokenServiceMock.Setup(x => x.GenerateAccessToken(It.IsAny<UserAccount>())).Returns("access-token");
-        _tokenServiceMock.Setup(x => x.GenerateRefreshToken(It.IsAny<UserAccount>())).Returns("refresh-token");
+        _tokenServiceMock
+            .Setup(x => x.GenerateAccessToken(It.IsAny<UserAccount>()))
+            .Returns("access-token");
+        _tokenServiceMock
+            .Setup(x => x.GenerateRefreshToken(It.IsAny<UserAccount>()))
+            .Returns("refresh-token");
        _mediatorMock
-            .Setup(x => x.Send(It.IsAny<SendRegistrationEmailCommand>(), It.IsAny<CancellationToken>()))
+            .Setup(x =>
+                x.Send(It.IsAny<SendRegistrationEmailCommand>(), It.IsAny<CancellationToken>())
+            )
            .ThrowsAsync(new Exception("smtp down"));

        RegistrationPayload result = await _handler.Handle(command, CancellationToken.None);
@@ -172,4 +275,4 @@ public class RegisterUserHandlerTests
        result.ConfirmationEmailSent.Should().BeFalse();
        result.AccessToken.Should().Be("access-token");
    }
-}
+}
--- a/web/backend/Features/Features.Auth.Tests/Commands/ResendConfirmationEmailHandlerTests.cs
+++ b/web/backend/Features/Features.Auth.Tests/Commands/ResendConfirmationEmailHandlerTests.cs
@@ -17,15 +17,23 @@ public class ResendConfirmationEmailHandlerTests

    public ResendConfirmationEmailHandlerTests()
    {
-        _handler = new ResendConfirmationEmailHandler(_authRepositoryMock.Object, _tokenServiceMock.Object,
-            _mediatorMock.Object);
+        _handler = new ResendConfirmationEmailHandler(
+            _authRepositoryMock.Object,
+            _tokenServiceMock.Object,
+            _mediatorMock.Object
+        );
    }

    [Fact]
    public async Task Handle_SendsFreshConfirmationEmail_WhenUserExistsAndUnverified()
    {
        Guid userId = Guid.NewGuid();
-        UserAccount user = new() { UserAccountId = userId, FirstName = "Aaron", Email = "aaron@example.com" };
+        UserAccount user = new()
+        {
+            UserAccountId = userId,
+            FirstName = "Aaron",
+            Email = "aaron@example.com",
+        };

        _authRepositoryMock.Setup(x => x.GetUserByIdAsync(userId)).ReturnsAsync(user);
        _authRepositoryMock.Setup(x => x.IsUserVerifiedAsync(userId)).ReturnsAsync(false);
@@ -34,9 +42,15 @@ public class ResendConfirmationEmailHandlerTests
        await _handler.Handle(new ResendConfirmationEmailCommand(userId), CancellationToken.None);

        _mediatorMock.Verify(
-            x => x.Send(It.Is<SendResendConfirmationEmailCommand>(c =>
-                c.FirstName == "Aaron" && c.Email == "aaron@example.com" && c.ConfirmationToken == "fresh-token"
-            ), It.IsAny<CancellationToken>()),
+            x =>
+                x.Send(
+                    It.Is<SendResendConfirmationEmailCommand>(c =>
+                        c.FirstName == "Aaron"
+                        && c.Email == "aaron@example.com"
+                        && c.ConfirmationToken == "fresh-token"
+                    ),
+                    It.IsAny<CancellationToken>()
+                ),
            Times.Once
        );
    }
@@ -50,7 +64,11 @@ public class ResendConfirmationEmailHandlerTests
        await _handler.Handle(new ResendConfirmationEmailCommand(userId), CancellationToken.None);

        _mediatorMock.Verify(
-            x => x.Send(It.IsAny<SendResendConfirmationEmailCommand>(), It.IsAny<CancellationToken>()),
+            x =>
+                x.Send(
+                    It.IsAny<SendResendConfirmationEmailCommand>(),
+                    It.IsAny<CancellationToken>()
+                ),
            Times.Never
        );
    }
@@ -67,8 +85,12 @@ public class ResendConfirmationEmailHandlerTests
        await _handler.Handle(new ResendConfirmationEmailCommand(userId), CancellationToken.None);

        _mediatorMock.Verify(
-            x => x.Send(It.IsAny<SendResendConfirmationEmailCommand>(), It.IsAny<CancellationToken>()),
+            x =>
+                x.Send(
+                    It.IsAny<SendResendConfirmationEmailCommand>(),
+                    It.IsAny<CancellationToken>()
+                ),
            Times.Never
        );
    }
-}
+}