Files
slp-modular-cms/src/SlpModularCms.Core.Tests/Identity/InvitationServiceTests.cs
T

212 lines
7.2 KiB
C#

using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using NSubstitute;
using SlpModularCms.Core.Data;
using SlpModularCms.Core.Identity.Entities;
using SlpModularCms.Core.Identity.Services;
using SlpModularCms.Core.Exceptions;
using Xunit;
using FluentAssertions;
namespace SlpModularCms.Core.Tests.Identity;
public class InvitationServiceTests
{
private readonly ApplicationDbContext _context;
private readonly UserManager<ApplicationUser> _userManager;
private readonly InvitationService _service;
public InvitationServiceTests()
{
var options = new DbContextOptionsBuilder<ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
_context = new ApplicationDbContext(options);
var store = Substitute.For<IUserStore<ApplicationUser>>();
_userManager = Substitute.For<UserManager<ApplicationUser>>(store, null, null, null, null, null, null, null, null);
_service = new InvitationService(_context, _userManager);
}
[Fact]
public async Task CreateInvitationAsync_ShouldCreateRecordInDb()
{
// Arrange
var email = "test@example.com";
var role = "User";
// Act
var token = await _service.CreateInvitationAsync(email, role);
// Assert
token.Should().NotBeNullOrEmpty();
var invitation = await _context.Invitations.FirstOrDefaultAsync(i => i.Token == token);
invitation.Should().NotBeNull();
invitation!.Email.Should().Be(email);
invitation.Role.Should().Be(role);
invitation.IsAccepted.Should().BeFalse();
}
[Fact]
public async Task ValidateInvitationAsync_ShouldReturnTrue_ForValidToken()
{
// Arrange
var token = await _service.CreateInvitationAsync("test@example.com", "User");
// Act
var isValid = await _service.ValidateInvitationAsync(token);
// Assert
isValid.Should().BeTrue();
}
[Fact]
public async Task CompleteInvitationAsync_ShouldCreateUserAndMarkAsAccepted()
{
// Arrange
var email = "test@example.com";
var role = "User";
var password = "SafePassword123!";
var token = await _service.CreateInvitationAsync(email, role);
_userManager.CreateAsync(Arg.Any<ApplicationUser>(), password)
.Returns(IdentityResult.Success);
_userManager.AddToRoleAsync(Arg.Any<ApplicationUser>(), role)
.Returns(IdentityResult.Success);
// Act
await _service.CompleteInvitationAsync(token, password);
// Assert
var invitation = await _context.Invitations.FirstOrDefaultAsync(i => i.Token == token);
invitation!.IsAccepted.Should().BeTrue();
await _userManager.Received(1).CreateAsync(Arg.Is<ApplicationUser>(u => u.Email == email), password);
await _userManager.Received(1).AddToRoleAsync(Arg.Any<ApplicationUser>(), role);
}
[Fact]
public async Task CompleteInvitationAsync_ShouldThrow_WhenTokenInvalid()
{
var act = () => _service.CompleteInvitationAsync("invalid-token", "password");
await act.Should().ThrowAsync<UnauthorizedException>();
}
[Fact]
public async Task CreateInvitationAsync_ShouldThrow_WhenInvitationAlreadyExists()
{
await _service.CreateInvitationAsync("test@example.com", "User");
var act = () => _service.CreateInvitationAsync("test@example.com", "User");
await act.Should().ThrowAsync<InvitationOrUserAlreadyExistsException>();
}
[Fact]
public async Task CreateInvitationAsync_ShouldThrow_WhenUserAlreadyExists()
{
var email = "existing@example.com";
_userManager.FindByEmailAsync(email)
.Returns(new ApplicationUser { Email = email });
var act = () => _service.CreateInvitationAsync(email, "User");
await act.Should().ThrowAsync<InvitationOrUserAlreadyExistsException>();
}
[Fact]
public async Task ValidateInvitationAsync_ShouldReturnFalse_WhenTokenInvalid()
{
var isValid = await _service.ValidateInvitationAsync("nonexistent-token");
isValid.Should().BeFalse();
}
[Fact]
public async Task GetPendingInvitationByEmailAsync_ShouldReturnFalse_WhenNoInvitation()
{
var (isPending, token) = await _service.GetPendingInvitationByEmailAsync("nobody@example.com");
isPending.Should().BeFalse();
token.Should().BeNull();
}
[Fact]
public async Task GetPendingInvitationByEmailAsync_ShouldReturnTrue_WhenPendingInvitationExists()
{
var invitationToken = await _service.CreateInvitationAsync("invited@example.com", "User");
var (isPending, token) = await _service.GetPendingInvitationByEmailAsync("invited@example.com");
isPending.Should().BeTrue();
token.Should().Be(invitationToken);
}
[Fact]
public async Task DeletePendingInvitationsByEmailAsync_ShouldRemoveMatchingInvitations()
{
await _service.CreateInvitationAsync("invited@example.com", "User");
await _service.DeletePendingInvitationsByEmailAsync("invited@example.com");
var (isPending, _) = await _service.GetPendingInvitationByEmailAsync("invited@example.com");
isPending.Should().BeFalse();
}
[Fact]
public async Task GetAllPendingInvitationsAsync_ShouldReturnAllActiveInvitations()
{
await _service.CreateInvitationAsync("user1@example.com", "User");
await _service.CreateInvitationAsync("user2@example.com", "Administrator");
var invitations = await _service.GetAllPendingInvitationsAsync();
invitations.Should().HaveCount(2);
invitations.Select(i => i.Email).Should().Contain(["user1@example.com", "user2@example.com"]);
}
[Fact]
public async Task DeleteInvitationByIdAsync_ShouldReturnTrue_WhenFound()
{
await _service.CreateInvitationAsync("invited@example.com", "User");
var invitations = await _service.GetAllPendingInvitationsAsync();
var id = invitations[0].Id;
var result = await _service.DeleteInvitationByIdAsync(id);
result.Should().BeTrue();
(await _service.GetAllPendingInvitationsAsync()).Should().BeEmpty();
}
[Fact]
public async Task DeleteInvitationByIdAsync_ShouldReturnFalse_WhenNotFound()
{
var result = await _service.DeleteInvitationByIdAsync(Guid.NewGuid());
result.Should().BeFalse();
}
[Fact]
public async Task UpdateInvitationRoleAsync_ShouldUpdateRole()
{
await _service.CreateInvitationAsync("invited@example.com", "User");
var invitations = await _service.GetAllPendingInvitationsAsync();
var id = invitations[0].Id;
var result = await _service.UpdateInvitationRoleAsync(id, "Administrator");
result.Should().BeTrue();
var updated = await _service.GetAllPendingInvitationsAsync();
updated[0].Role.Should().Be("Administrator");
}
[Fact]
public async Task UpdateInvitationRoleAsync_ShouldReturnFalse_WhenNotFound()
{
var result = await _service.UpdateInvitationRoleAsync(Guid.NewGuid(), "Administrator");
result.Should().BeFalse();
}
}