Test/ssad 0029/mediat r/additional content tests

Streetcode/Streetcode.XUnitTest/MediatR/AdditionalContent/Cordinate/Create/CreateCoordinateHandlerTests.cs

@@ -0,0 +1,121 @@
+using AutoMapper;
+using FluentAssertions;
+using MediatR;
+using Moq;
+using Streetcode.BLL.DTO.AdditionalContent.Coordinates.Types;
+using Streetcode.BLL.MediatR.AdditionalContent.Coordinate.Create;
+using Streetcode.BLL.Mapping.AdditionalContent.Coordinates;
+using Streetcode.DAL.Entities.AdditionalContent.Coordinates.Types;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+using Streetcode.Resources;
+using Streetcode.Shared.Extensions;
+using Xunit;
+
+namespace Streetcode.XUnitTest.MediatR.AdditionalContent.Coordinate;
+
+public class CreateCoordinateHandlerTests
+{
+    private readonly Mock<IRepositoryWrapper> _mockRepo;
+    private readonly IMapper _mapper;
+
+    public CreateCoordinateHandlerTests()
+    {
+        _mockRepo = new Mock<IRepositoryWrapper>();
+
+        var configuration = new MapperConfiguration(cfg =>
+        {
+            cfg.AddProfile(new StreetcodeCoordinateProfile());
+            // Ensure mapping from DTO to Entity is available if not in profile
+            cfg.CreateMap<StreetcodeCoordinateDTO, StreetcodeCoordinate>();
+        });
+
+        _mapper = configuration.CreateMapper();
+    }
+
+    [Fact]
+    public async Task Handle_ValidRequest_ReturnsSuccessAndCallsCreate()
+    {
+        // Arrange
+        var command = new CreateCoordinateCommand(
+            new StreetcodeCoordinateDTO
+            {
+                Latitude = 10,
+                Longtitude = 20
+            });
+
+        // FIXED: Changed Create to CreateAsync to match the Handler implementation
+        _mockRepo.Setup(r => r.StreetcodeCoordinateRepository.CreateAsync(
+            It.IsAny<StreetcodeCoordinate>()))
+            .ReturnsAsync(new StreetcodeCoordinate());
+
+        _mockRepo.Setup(r => r.SaveChangesAsync())
+            .ReturnsAsync(1);
+
+        var handler = new CreateCoordinateHandler(
+            _mockRepo.Object,
+            _mapper);
+
+        // Act
+        var result = await handler.Handle(
+            command,
+            CancellationToken.None);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Should().Be(Unit.Value);
+
+        // FIXED: Verifying CreateAsync because that is what the Handler actually invokes
+        _mockRepo.Verify(r => r.StreetcodeCoordinateRepository.CreateAsync(
+            It.IsAny<StreetcodeCoordinate>()), Times.Once);
+
+        _mockRepo.Verify(r => r.SaveChangesAsync(), Times.Once);
+    }
+
+    [Fact]
+    public async Task Handle_MapperReturnsNull_ReturnsFailure()
+    {
+        // Arrange
+        // Passing null ensures the mapper returns null or throws, 
+        // triggering the safety check in the Handler.
+        var command = new CreateCoordinateCommand(null!);
+
+        var handler = new CreateCoordinateHandler(
+            _mockRepo.Object,
+            _mapper);
+
+        var expectedError = Messages.Error_ConvertNullToEntity.Format(
+            nameof(StreetcodeCoordinate));
+
+        // Act
+        var result = await handler.Handle(
+            command,
+            CancellationToken.None);
+
+        // Assert
+        result.IsFailed.Should().BeTrue();
+        result.Errors.Should().ContainSingle()
+            .Which.Message.Should().Be(expectedError);
+    }
+
+    [Fact]
+    public async Task Handle_SaveFails_ReturnsFailure()
+    {
+        // Arrange
+        var command = new CreateCoordinateCommand(new StreetcodeCoordinateDTO());
+
+        _mockRepo.Setup(r => r.StreetcodeCoordinateRepository.CreateAsync(It.IsAny<StreetcodeCoordinate>()))
+            .ReturnsAsync(new StreetcodeCoordinate());
+
+        // Simulate database save failure (returning 0 rows affected)
+        _mockRepo.Setup(r => r.SaveChangesAsync())
+            .ReturnsAsync(0);
+
+        var handler = new CreateCoordinateHandler(_mockRepo.Object, _mapper);
+
+        // Act
+        var result = await handler.Handle(command, CancellationToken.None);
+
+        // Assert
+        result.IsFailed.Should().BeTrue();
+    }
+}

Streetcode/Streetcode.XUnitTest/MediatR/AdditionalContent/Cordinate/Delete/DeleteCoordinateHandlerTests.cs

@@ -0,0 +1,102 @@
+using System.Linq.Expressions;
+using FluentAssertions;
+using FluentResults;
+using MediatR;
+using Microsoft.EntityFrameworkCore.Query;
+using Moq;
+using Streetcode.BLL.MediatR.AdditionalContent.Coordinate.Delete;
+using Streetcode.DAL.Entities.AdditionalContent.Coordinates.Types;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+using Xunit;
+
+namespace Streetcode.XUnit.BLL.MediatR.AdditionalContent.Coordinate;
+
+public class DeleteCoordinateHandlerTests
+{
+    private readonly Mock<IRepositoryWrapper> _mockRepositoryWrapper;
+
+    public DeleteCoordinateHandlerTests()
+    {
+        _mockRepositoryWrapper = new Mock<IRepositoryWrapper>();
+    }
+
+    [Fact]
+    public async Task Handle_CoordinateNotFound_ReturnsFailResult()
+    {
+        // Arrange
+        int testId = 1;
+
+        _mockRepositoryWrapper.Setup(repo => repo.StreetcodeCoordinateRepository
+            .GetFirstOrDefaultAsync(
+                It.IsAny<Expression<Func<StreetcodeCoordinate, bool>>>(),
+                It.IsAny<Func<IQueryable<StreetcodeCoordinate>, IIncludableQueryable<StreetcodeCoordinate, object>>>(),
+                It.IsAny<bool>()))
+            .ReturnsAsync((StreetcodeCoordinate?)null);
+
+        var handler = new DeleteCoordinateHandler(_mockRepositoryWrapper.Object);
+        var command = new DeleteCoordinateCommand(testId);
+
+        // Act
+        var result = await handler.Handle(command, CancellationToken.None);
+
+        // Assert
+        result.IsFailed.Should().BeTrue();
+        _mockRepositoryWrapper.Verify(r => r.StreetcodeCoordinateRepository.Delete(It.IsAny<StreetcodeCoordinate>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task Handle_CoordinateExists_DeletesAndReturnsOkResult()
+    {
+        // Arrange
+        int testId = 1;
+        var coordinate = new StreetcodeCoordinate { Id = testId };
+
+        _mockRepositoryWrapper.Setup(repo => repo.StreetcodeCoordinateRepository
+            .GetFirstOrDefaultAsync(
+                It.IsAny<Expression<Func<StreetcodeCoordinate, bool>>>(),
+                It.IsAny<Func<IQueryable<StreetcodeCoordinate>, IIncludableQueryable<StreetcodeCoordinate, object>>>(),
+                It.IsAny<bool>()))
+            .ReturnsAsync(coordinate);
+
+        _mockRepositoryWrapper.Setup(repo => repo.SaveChangesAsync())
+            .ReturnsAsync(1);
+
+        var handler = new DeleteCoordinateHandler(_mockRepositoryWrapper.Object);
+        var command = new DeleteCoordinateCommand(testId);
+
+        // Act
+        var result = await handler.Handle(command, CancellationToken.None);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        _mockRepositoryWrapper.Verify(r => r.StreetcodeCoordinateRepository.Delete(coordinate), Times.Once);
+        _mockRepositoryWrapper.Verify(r => r.SaveChangesAsync(), Times.Once);
+    }
+
+    [Fact]
+    public async Task Handle_SaveChangesAsyncFails_ReturnsFailResult()
+    {
+        // Arrange
+        int testId = 1;
+        var coordinate = new StreetcodeCoordinate { Id = testId };
+
+        _mockRepositoryWrapper.Setup(repo => repo.StreetcodeCoordinateRepository
+            .GetFirstOrDefaultAsync(
+                It.IsAny<Expression<Func<StreetcodeCoordinate, bool>>>(),
+                It.IsAny<Func<IQueryable<StreetcodeCoordinate>, IIncludableQueryable<StreetcodeCoordinate, object>>>(),
+                It.IsAny<bool>()))
+            .ReturnsAsync(coordinate);
+
+        _mockRepositoryWrapper.Setup(repo => repo.SaveChangesAsync())
+            .ReturnsAsync(0);
+
+        var handler = new DeleteCoordinateHandler(_mockRepositoryWrapper.Object);
+        var command = new DeleteCoordinateCommand(testId);
+
+        // Act
+        var result = await handler.Handle(command, CancellationToken.None);
+
+        // Assert
+        result.IsFailed.Should().BeTrue();
+    }
+}

Streetcode/Streetcode.XUnitTest/MediatR/AdditionalContent/Cordinate/GetByStreetcodeId/GetCoordinatesByStreetcodeIdHandlerTests.cs

@@ -0,0 +1,70 @@
+using AutoMapper;
+using FluentAssertions;
+using Microsoft.EntityFrameworkCore.Query;
+using Moq;
+using Streetcode.BLL.DTO.AdditionalContent.Coordinates.Types;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.BLL.Mapping.AdditionalContent.Coordinates;
+using Streetcode.BLL.MediatR.AdditionalContent.Coordinate.GetByStreetcodeId;
+using Streetcode.DAL.Entities.AdditionalContent.Coordinates.Types;
+using Streetcode.DAL.Entities.Streetcode;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+using Streetcode.Resources;
+using Streetcode.Shared.Extensions;
+using System.Linq.Expressions;
+using Xunit;
+
+namespace Streetcode.XUnitTest.MediatR.AdditionalContent.Coordinate;
+
+public class GetCoordinatesByStreetcodeIdHandlerTests
+{
+    private readonly Mock<IRepositoryWrapper> _mockRepo;
+    private readonly Mock<ILoggerService> _mockLogger;
+    private readonly IMapper _mapper;
+
+    public GetCoordinatesByStreetcodeIdHandlerTests()
+    {
+        _mockRepo = new Mock<IRepositoryWrapper>();
+        _mockLogger = new Mock<ILoggerService>();
+
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.AddProfile(new StreetcodeCoordinateProfile());
+        });
+        _mapper = config.CreateMapper();
+    }
+
+    [Fact]
+    public async Task Handle_StreetcodeExists_ReturnsCorrectDataAndType()
+    {
+        // Arrange
+        int streetcodeId = 1;
+        var query = new GetCoordinatesByStreetcodeIdQuery(streetcodeId);
+        var coordinates = new List<StreetcodeCoordinate>
+        {
+            new() { Id = 1, StreetcodeId = streetcodeId, Latitude = 1.1m, Longtitude = 2.2m }
+        };
+
+        _mockRepo.Setup(r => r.StreetcodeRepository.GetFirstOrDefaultAsync(
+            It.IsAny<Expression<Func<StreetcodeContent, bool>>>(),
+            It.IsAny<Func<IQueryable<StreetcodeContent>, IIncludableQueryable<StreetcodeContent, object>>>(),
+            It.IsAny<bool>()))
+            .ReturnsAsync(new StreetcodeContent { Id = streetcodeId });
+
+        _mockRepo.Setup(r => r.StreetcodeCoordinateRepository.GetAllAsync(
+            It.IsAny<Expression<Func<StreetcodeCoordinate, bool>>>(),
+            It.IsAny<Func<IQueryable<StreetcodeCoordinate>, IIncludableQueryable<StreetcodeCoordinate, object>>>(),
+            It.IsAny<bool>()))
+            .ReturnsAsync(coordinates);
+
+        var handler = new GetCoordinatesByStreetcodeIdHandler(_mockRepo.Object, _mapper, _mockLogger.Object);
+
+        // Act
+        var result = await handler.Handle(query, CancellationToken.None);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Should().NotBeNull();
+    }
+
+}