OptifitWebService/TestAPI/MapperTests/AlumniMappersTests.cs

using Server.Mappers;
using Server.Dto.Request;
using Infrastructure.Entities;
using Shared.Enums;

namespace TestAPI.MapperTests
{
    public class AlumniMappersTests
    {
        [Fact]
        public void ToDto_ConvertsAlumniEntityToResponseAlumniDto()
        {
            // Arrange
            var alumniEntity = new User
            {
                Id = "1",
                Email = "test@example.com",
                Role = "USER",
                EntryYear = "2020",
                FirstName = "John",
                LastName = "Doe",
                Linkedin = "linkedin.com",
                Github = "github.com",
                WebSite = "portfolio.com",
                Experiences = (ICollection<ExperienceEntity>)Enumerable.Empty<ExperienceEntity>(),
                Formations = (ICollection<FormationEntity>)Enumerable.Empty<FormationEntity>()
            };

            // Act
            var result = alumniEntity.ToDto();

            // Assert
            Assert.Equal(alumniEntity.Id, result.Id);
            Assert.Equal(alumniEntity.Email, result.Email);
            Assert.Equal(ERole.USER, result.ERole);
            Assert.Equal(alumniEntity.EntryYear, result.EntryYear);
            Assert.Equal(alumniEntity.FirstName, result.FirstName);
            Assert.Equal(alumniEntity.LastName, result.LastName);
            Assert.Equal(alumniEntity.Linkedin, result.LinkedinUrl);
            Assert.Equal(alumniEntity.Github, result.GithubUrl);
            Assert.Equal(alumniEntity.WebSite, result.PortfolioUrl);
            Assert.Empty(result.Experiences);
            Assert.Empty(result.Formations);
        }

        [Fact]
        public void ToDtoRestricted_ConvertsAlumniEntityToResponseRestrictedAlumniDto()
        {
            // Arrange
            var alumniEntity = new User
            {
                Id = "1",
                FirstName = "John",
                LastName = "Doe",
                Linkedin = "linkedin.com"
            };

            // Act
            var result = alumniEntity.ToDtoRestricted();

            // Assert
            Assert.Equal(alumniEntity.Id, result.Id);
            Assert.Equal(alumniEntity.FirstName, result.FirstName);
            Assert.Equal(alumniEntity.LastName, result.LastName);
            Assert.Equal(alumniEntity.Linkedin, result.LinkedinUrl);
        }

        [Fact]
        public void ToEntity_ConvertsRequestAlumniDtoToAlumniEntity()
        {
            // Arrange
            var requestAlumniDto = new RequestAlumniDto
            {
                Email = "test@example.com",
                Password = "password",
                EntryYear = "2020",
                FirstName = "John",
                LastName = "Doe",
                LinkedinUrl = "linkedin.com",
                GithubUrl = "github.com",
                PortfolioUrl = "portfolio.com"
            };

            // Act
            var result = requestAlumniDto.ToEntity();

            // Assert
            Assert.Equal(requestAlumniDto.Email, result.Email);
            Assert.Equal(requestAlumniDto.Password, result.Password);
            Assert.Equal(requestAlumniDto.EntryYear, result.EntryYear);
            Assert.Equal(requestAlumniDto.FirstName, result.FirstName);
            Assert.Equal(requestAlumniDto.LastName, result.LastName);
            Assert.Equal(requestAlumniDto.LinkedinUrl, result.Linkedin);
            Assert.Equal(requestAlumniDto.GithubUrl, result.Github);
            Assert.Equal(requestAlumniDto.PortfolioUrl, result.WebSite);
            Assert.Equal("USER", result.Role);
        }

        [Theory]
        [InlineData("ADMIN", ERole.ADMIN)]
        [InlineData("MODERATOR", ERole.MODERATOR)]
        [InlineData("USER", ERole.USER)]
        public void ToERole_ConvertsStringToERole(string role, ERole expectedRole)
        {
            // Act
            var result = role.ToERole();

            // Assert
            Assert.Equal(expectedRole, result);
        }
    }
}