test/12: add test for BLL/MediatR/Team

Streetcode/Streetcode.XUnitTest/BLL/MediatR/Team/GetAllMainTeamQueryTests.cs

@@ -0,0 +1,68 @@
+using AutoMapper;
+using FluentAssertions;
+using Microsoft.EntityFrameworkCore.Query;
+using Moq;
+using Streetcode.BLL.DTO.Team;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.BLL.MediatR.Team.GetAll;
+using Streetcode.DAL.Entities.Team;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+using System.Linq.Expressions;
+using Xunit;
+
+namespace Streetcode.XUnitTest.MediatR.Team.GetAll;
+
+public class GetAllMainTeamHandlerTests
+{
+    private readonly Mock<IRepositoryWrapper> _mockRepo;
+    private readonly IMapper _mapper;
+    private readonly Mock<ILoggerService> _mockLogger;
+    private readonly GetAllMainTeamHandler _handler;
+
+    public GetAllMainTeamHandlerTests()
+    {
+        _mockRepo = new Mock<IRepositoryWrapper>();
+        this._mapper = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<TeamMember, TeamMemberDTO>();
+        }).CreateMapper();
+        _mockLogger = new Mock<ILoggerService>();
+        _handler = new GetAllMainTeamHandler(_mockRepo.Object, _mapper, _mockLogger.Object);
+    }
+
+    [Fact]
+    public async Task Handle_ReturnsOkResult_WhenMainTeamExists()
+    {
+        var mainTeamEntities = new List<TeamMember>
+        {
+            new TeamMember { Id = 1, FirstName = "John", LastName = "Doe", IsMain = true },
+            new TeamMember { Id = 2, FirstName = "Jane", LastName = "Smith", IsMain = true }
+        };
+        var mainTeamDTOs = mainTeamEntities.Select(tm => this._mapper.Map<TeamMemberDTO>(tm)).ToList();
+
+        _mockRepo.Setup(
+           repo => repo.TeamRepository.GetAllAsync(
+               It.IsAny<Expression<Func<TeamMember, bool>>>(),
+               It.IsAny<Func<IQueryable<TeamMember>, IIncludableQueryable<TeamMember, object>>>()
+           )
+       ).ReturnsAsync(mainTeamEntities);
+
+        var result = await _handler.Handle(new GetAllMainTeamQuery(), CancellationToken.None);
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Should().BeEquivalentTo(mainTeamDTOs);
+    }
+
+    [Fact]
+    public async Task Handle_ReturnsFailResult_WhenNoMainTeamExists()
+    {
+        _mockRepo.Setup(
+           repo => repo.TeamRepository.GetAllAsync(
+               It.IsAny<Expression<Func<TeamMember, bool>>>(),
+               It.IsAny<Func<IQueryable<TeamMember>, IIncludableQueryable<TeamMember, object>>>()
+           )
+       ).ReturnsAsync((IEnumerable<TeamMember>)null);
+        var result = await _handler.Handle(new GetAllMainTeamQuery(), CancellationToken.None);
+        result.IsFailed.Should().BeTrue();
+        result.Errors.Should().ContainSingle(e => e.Message == "Cannot find any team");
+    }
+}

Streetcode/Streetcode.XUnitTest/BLL/MediatR/Team/GetAllTeamHandlerTests.cs

@@ -0,0 +1,85 @@
+using AutoMapper;
+using FluentAssertions;
+using Microsoft.EntityFrameworkCore.Query;
+using Moq;
+using Streetcode.BLL.DTO.Team;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.BLL.MediatR.Team.GetAll;
+using Streetcode.DAL.Entities.Team;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+using Streetcode.DAL.Repositories.Interfaces.Team;
+using System.Linq.Expressions;
+using Xunit;
+
+namespace Streetcode.XUnitTest.MediatR.Team.GetAll;
+
+public class GetAllTeamHandlerTests
+{
+    private readonly Mock<IRepositoryWrapper> _mockRepo;
+    private readonly Mock<ITeamRepository> _mockTeamRepo;
+    private readonly IMapper _mapper;
+    private readonly Mock<ILoggerService> _mockLogger;
+    private readonly GetAllTeamHandler _handler;
+
+    public GetAllTeamHandlerTests()
+    {
+        _mockRepo = new Mock<IRepositoryWrapper>();
+        _mockTeamRepo = new Mock<ITeamRepository>();
+
+        this._mapper = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<TeamMember, TeamMemberDTO>();
+        }).CreateMapper();
+
+        _mockLogger = new Mock<ILoggerService>();
+
+        _mockRepo.Setup(x => x.TeamRepository).Returns(_mockTeamRepo.Object);
+        _handler = new GetAllTeamHandler(_mockRepo.Object, _mapper, _mockLogger.Object);
+    }
+
+    [Fact]
+    public async Task Handle_ReturnsOkResult_WhenTeamExists()
+    {
+        var teamEntities = new List<TeamMember>
+        {
+            new TeamMember { Id = 1, FirstName = "John", LastName = "Doe" },
+            new TeamMember { Id = 2, FirstName = "Jane", LastName = "Smith" }
+        };
+        var teamDTOs = new List<TeamMemberDTO>
+        {
+             this._mapper.Map<TeamMemberDTO>(teamEntities.ElementAt(0)),
+             this._mapper.Map<TeamMemberDTO>(teamEntities.ElementAt(1)),
+        };
+
+        _mockTeamRepo.Setup(
+            repo => repo.GetAllAsync(
+                It.IsAny<Expression<Func<TeamMember, bool>>>(),
+                It.IsAny<Func<IQueryable<TeamMember>, IIncludableQueryable<TeamMember, object>>>()
+            )
+        ).ReturnsAsync(teamEntities);    
+
+        var query = new GetAllTeamQuery();
+
+        var result = await _handler.Handle(query, CancellationToken.None);
+
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Should().BeEquivalentTo(teamDTOs);
+    }
+
+    [Fact]
+    public async Task Handle_ReturnsFailResult_WhenNoTeamExists()
+    {
+        _mockTeamRepo.Setup(
+            repo => repo.GetAllAsync(
+                It.IsAny<Expression<Func<TeamMember, bool>>>(),
+                It.IsAny<Func<IQueryable<TeamMember>, IIncludableQueryable<TeamMember, object>>>()
+            )
+        ).ReturnsAsync((IEnumerable<TeamMember>)null);
+        var query = new GetAllTeamQuery();
+
+        var result = await _handler.Handle(query, CancellationToken.None);
+
+        result.IsFailed.Should().BeTrue();
+        result.Errors.Should().ContainSingle(e => e.Message == "Cannot find any team");
+    }
+}

Streetcode/Streetcode.XUnitTest/BLL/MediatR/Team/GetByIdTeamHandlerTests.cs

@@ -0,0 +1,68 @@
+using AutoMapper;
+using FluentAssertions;
+using Microsoft.EntityFrameworkCore.Query;
+using Moq;
+using Streetcode.BLL.DTO.Team;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.BLL.MediatR.Team.GetAll;
+using Streetcode.BLL.MediatR.Team.GetById;
+using Streetcode.DAL.Entities.Team;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+using Streetcode.DAL.Repositories.Interfaces.Team;
+using System.Linq.Expressions;
+using Xunit;
+
+namespace Streetcode.XUnitTest.BLL.MediatR.Team
+{
+    public class GetByIdTeamHandlerTests
+    {
+        private readonly Mock<IRepositoryWrapper> _mockRepo;
+        private readonly Mock<ITeamRepository> _mockTeamRepo;
+        private readonly IMapper _mapper;
+        private readonly Mock<ILoggerService> _mockLogger;
+        private readonly GetByIdTeamHandler _handler;
+        public GetByIdTeamHandlerTests()
+        {
+            _mockRepo = new Mock<IRepositoryWrapper>();
+            _mockTeamRepo = new Mock<ITeamRepository>();
+            this._mapper = new MapperConfiguration(cfg =>
+            {
+                cfg.CreateMap<TeamMember, TeamMemberDTO>();
+            }).CreateMapper();
+            _mockLogger = new Mock<ILoggerService>();
+            _mockRepo.Setup(x => x.TeamRepository).Returns(_mockTeamRepo.Object);
+            _handler = new GetByIdTeamHandler(_mockRepo.Object, _mapper, _mockLogger.Object);
+        }
+
+
+    [Fact]
+        public async Task Handle_ReturnsOkResult_WhenTeamExists()
+        {
+            var teamEntity = new TeamMember { Id = 1, FirstName = "John", LastName = "Doe" };
+            var teamDTO = this._mapper.Map<TeamMemberDTO>(teamEntity);
+            _mockTeamRepo.Setup(
+                repo => repo.GetSingleOrDefaultAsync(
+                    It.IsAny<Expression<Func<TeamMember, bool>>>(),
+                    It.IsAny<Func<IQueryable<TeamMember>, IIncludableQueryable<TeamMember, object>>>()
+                )
+            ).ReturnsAsync(teamEntity);
+            var result = await _handler.Handle(new GetByIdTeamQuery(1), CancellationToken.None);
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().BeEquivalentTo(teamDTO);
+        }
+
+        [Fact]
+        public async Task Handle_ReturnsFailResult_WhenTeamDoesNotExist()
+        {
+            _mockTeamRepo.Setup(
+                repo => repo.GetSingleOrDefaultAsync(
+                    It.IsAny<Expression<Func<TeamMember, bool>>>(),
+                    It.IsAny<Func<IQueryable<TeamMember>, IIncludableQueryable<TeamMember, object>>>()
+                )
+            ).ReturnsAsync((TeamMember)null);
+            var result = await _handler.Handle(new GetByIdTeamQuery(1), CancellationToken.None);
+            result.IsFailed.Should().BeTrue();
+            result.Errors.Should().ContainSingle(e => e.Message.Contains("Cannot find"));
+        }
+    }
+}

Streetcode/Streetcode.XUnitTest/BLL/MediatR/Team/Position/CreatePositionHandlerTests.cs

@@ -0,0 +1,75 @@
+using AutoMapper;
+using FluentAssertions;
+using Moq;
+using Streetcode.BLL.DTO.Team;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.BLL.MediatR.Team.Create;
+using Streetcode.DAL.Entities.Team;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+using Streetcode.DAL.Repositories.Interfaces.Team;
+using Xunit;
+
+namespace Streetcode.XUnitTest.BLL.MediatR.Team.Position
+{
+    public class CreatePositionHandlerTests
+    {
+        private readonly Mock<IRepositoryWrapper> _mockRepo;
+        private readonly Mock<ITeamRepository> _mockTeamRepo;
+        private readonly IMapper _mapper;
+        private readonly Mock<ILoggerService> _mockLogger;
+        private readonly CreatePositionHandler _handler;
+
+        public CreatePositionHandlerTests()
+        {
+            _mockRepo = new Mock<IRepositoryWrapper>();
+            _mockTeamRepo = new Mock<ITeamRepository>();
+            this._mapper = new MapperConfiguration(cfg =>
+            {
+                cfg.CreateMap<Positions, PositionDTO>();
+                cfg.CreateMap<PositionDTO, Positions>();
+            }).CreateMapper();
+            _mockLogger = new Mock<ILoggerService>();
+            _mockRepo.Setup(x => x.TeamRepository).Returns(_mockTeamRepo.Object);
+            _handler = new CreatePositionHandler(_mapper, _mockRepo.Object, _mockLogger.Object);
+        }
+
+        [Fact]
+        public async Task Handle_ShouldCreatePosition_WhenDataIsValid()
+        {
+            var positionDTO = new PositionDTO { Position = "Developer" };
+            var positionEntity = new Positions { Id = 1, Position = "Developer" };
+
+            _mockRepo.Setup(repo => repo.PositionRepository.CreateAsync(It.IsAny<Positions>()))
+                .ReturnsAsync(positionEntity);
+
+            _mockRepo.Setup(repo => repo.SaveChanges()).Returns(1); 
+
+            var result = await _handler.Handle(new CreatePositionQuery(positionDTO), CancellationToken.None);
+
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().NotBeNull();
+            result.Value.Position.Should().Be(positionDTO.Position);
+
+            _mockRepo.Verify(repo => repo.SaveChanges(), Times.Once);
+        }
+
+        [Fact]
+        public async Task Handle_ShouldReturnFailure_WhenSaveChangesThrowsException()
+        {
+
+            var positionDTO = new PositionDTO { Position = "Developer" };
+            var positionEntity = new Positions { Id = 1, Position = "Developer" };
+            _mockRepo.Setup(repo => repo.PositionRepository.CreateAsync(It.IsAny<Positions>()))
+                .ReturnsAsync(positionEntity);
+
+            _mockRepo.Setup(repo => repo.SaveChanges()).Throws(new Exception("Database error"));
+
+            var result = await _handler.Handle(new CreatePositionQuery(positionDTO), CancellationToken.None);
+
+            result.IsFailed.Should().BeTrue();
+            result.Errors.Should().ContainSingle(e => e.Message == "Database error");
+
+            _mockRepo.Verify(repo => repo.SaveChanges(), Times.Once);
+        }
+    }
+}

Streetcode/Streetcode.XUnitTest/BLL/MediatR/Team/Position/GetAllPositionsHandlerTests.cs

@@ -0,0 +1,74 @@
+using AutoMapper;
+using FluentAssertions;
+using Microsoft.EntityFrameworkCore.Query;
+using Moq;
+using Streetcode.BLL.DTO.Team;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.BLL.MediatR.Team.Position.GetAll;
+using Streetcode.DAL.Entities.Team;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+using Streetcode.DAL.Repositories.Interfaces.Team; 
+using System.Linq.Expressions;
+using Xunit;
+
+namespace Streetcode.XUnitTest.BLL.MediatR.Team.Position
+{
+    public class GetAllPositionsHandlerTests
+    {
+        private readonly Mock<IRepositoryWrapper> _mockRepo;
+        private readonly Mock<IPositionRepository> _mockPositionRepo;
+        private readonly IMapper _mapper;
+        private readonly Mock<ILoggerService> _mockLogger;
+        private readonly GetAllPositionsHandler _handler;
+
+        public GetAllPositionsHandlerTests()
+        {
+            _mockRepo = new Mock<IRepositoryWrapper>();
+            _mockPositionRepo = new Mock<IPositionRepository>();
+
+            _mapper = new MapperConfiguration(cfg =>
+            {
+                cfg.CreateMap<Positions, PositionDTO>();
+            }).CreateMapper();
+
+            _mockLogger = new Mock<ILoggerService>();
+
+            _mockRepo.Setup(x => x.PositionRepository).Returns(_mockPositionRepo.Object);
+
+            _handler = new GetAllPositionsHandler(_mockRepo.Object, _mapper, _mockLogger.Object);
+        }
+
+        [Fact]
+        public async Task Handle_ShouldReturnPositions_WhenPositionsExist()
+        {
+            var positions = new List<Positions>
+            {
+                new Positions { Id = 1, Position = "Position 1" },
+                new Positions { Id = 2, Position = "Position 2" }
+            };
+
+            _mockPositionRepo.Setup(repo => repo.GetAllAsync(
+                It.IsAny<Expression<Func<Positions, bool>>>(),
+                It.IsAny<Func<IQueryable<Positions>, IIncludableQueryable<Positions, object>>>() 
+            )).ReturnsAsync(positions);
+
+            var result = await _handler.Handle(new GetAllPositionsQuery(), CancellationToken.None);
+
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().HaveCount(2);
+            result.Value.Should().BeEquivalentTo(_mapper.Map<IEnumerable<PositionDTO>>(positions));
+        }
+
+        [Fact]
+        public async Task Handle_ShouldReturnFailure_WhenNoPositionsExist()
+        {
+            _mockPositionRepo.Setup(repo => repo.GetAllAsync(
+                It.IsAny<Expression<Func<Positions, bool>>>(),
+                It.IsAny<Func<IQueryable<Positions>, IIncludableQueryable<Positions, object>>>() 
+            )).ReturnsAsync((IEnumerable<Positions>)null);
+            var result = await _handler.Handle(new GetAllPositionsQuery(), CancellationToken.None);
+            result.IsFailed.Should().BeTrue();
+            result.Errors.Should().ContainSingle(e => e.Message == "Cannot find any positions");
+        }
+    }
+}