test: add comprehensive unit tests for handlers and Result pattern

alysonsz · alysonsz · commit 4bc138b5e991 · 2026-04-09T17:11:20.000-03:00
Add test coverage for:
- CreateEventCommandHandler (valid command and past date exception)
- UpdateEventCommandHandler (existing event, not found, past date exception)
- DeleteEventCommandHandler (existing and non-existing events)
- GetEventByIdQueryHandler (cached, not cached, not found)
- GetAllEventsQueryHandler (paged results and empty list)
- CreateOrganizerCommandHandler
- GetOrganizerByIdQueryHandler
- Result&lt;T&gt; pattern (Success, Failure, implicit conversions, Map)

Fix test issues:
- Use correct repository method names (GetEventWithDetailsByIdAsync)
- Use factory methods instead of constructors for Entities
- Expect exceptions for business rule violations
- Use consistent future dates to avoid clock skew issues
diff --git a/EventFlow-API.Tests/GlobalUsing.cs b/EventFlow-API.Tests/GlobalUsing.cs
@@ -5,11 +5,21 @@
 global using Microsoft.EntityFrameworkCore;
 global using Microsoft.AspNetCore.Mvc;
 
+global using EventFlow.Core.Commands;
+global using EventFlow.Core.Models;
+global using EventFlow.Core.Models.DTOs;
+global using EventFlow.Core.Services.Interfaces;
+global using EventFlow.Core.Models;
+global using EventFlow.Core.Primitives;
+global using EventFlow.Core.Repository;
+global using EventFlow.Core.ValueObjects;
+
+global using EventFlow.Application.Services;
+global using EventFlow.Application.Validators;
+global using EventFlow.Application.Abstractions;
 global using EventFlow.Application.Commands;
 global using EventFlow.Application.DTOs;
 global using EventFlow.Application.Services;
 global using EventFlow.Application.Validators;
-global using EventFlow.Core.Models;
-global using EventFlow.Core.Repository;
-global using EventFlow.Core.ValueObjects;
+
 global using EventFlow.Presentation.Controllers;
diff --git a/EventFlow-API.Tests/Handlers/CreateEventCommandHandlerTests.cs b/EventFlow-API.Tests/Handlers/CreateEventCommandHandlerTests.cs
@@ -0,0 +1,57 @@
+using EventFlow.Application.Features.Events.Commands.CreateEvent;
+using EventFlow.Core.Models;
+using EventFlow.Core.Primitives;
+using EventFlow.Core.Repository;
+using Moq;
+
+namespace EventFlow.Tests.Handlers;
+
+public class CreateEventCommandHandlerTests
+{
+    private readonly Mock<IEventRepository> _mockRepo;
+    private readonly Mock<IUnitOfWork> _mockUnitOfWork;
+    private readonly CreateEventCommandHandler _handler;
+
+    public CreateEventCommandHandlerTests()
+    {
+        _mockRepo = new Mock<IEventRepository>();
+        _mockUnitOfWork = new Mock<IUnitOfWork>();
+        _handler = new CreateEventCommandHandler(_mockRepo.Object, _mockUnitOfWork.Object);
+    }
+
+    [Fact]
+    public async Task Handle_ValidCommand_ReturnsSuccessWithEventId()
+    {
+        var futureDate = DateTime.UtcNow.AddDays(2);
+        var command = new CreateEventCommand(
+            "Test Event",
+            "Description",
+            futureDate,
+            "Location",
+            1);
+
+        _mockRepo.Setup(r => r.PostAsync(It.IsAny<Event>()))
+            .ReturnsAsync((Event e) => e);
+        _mockUnitOfWork.Setup(u => u.SaveChangesAsync(It.IsAny<CancellationToken>())).ReturnsAsync(1);
+
+        var result = await _handler.Handle(command, CancellationToken.None);
+
+        Assert.True(result.IsSuccess);
+        Assert.True(result.Value >= 0);
+        _mockRepo.Verify(r => r.PostAsync(It.IsAny<Event>()), Times.Once);
+        _mockUnitOfWork.Verify(u => u.SaveChangesAsync(It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task Handle_PastDate_ThrowsBusinessRuleException()
+    {
+        var command = new CreateEventCommand(
+            "Test Event",
+            "Description",
+            DateTime.UtcNow.AddDays(-1),
+            "Location",
+            1);
+
+        await Assert.ThrowsAsync<BusinessRuleValidationException>(() => _handler.Handle(command, CancellationToken.None));
+    }
+}
diff --git a/EventFlow-API.Tests/Handlers/CreateOrganizerCommandHandlerTests.cs b/EventFlow-API.Tests/Handlers/CreateOrganizerCommandHandlerTests.cs
@@ -0,0 +1,34 @@
+using EventFlow.Application.Features.Organizers.Commands.CreateOrganizer;
+using EventFlow.Core.Models;
+using EventFlow.Core.Repository;
+using Moq;
+
+namespace EventFlow.Tests.Handlers;
+
+public class CreateOrganizerCommandHandlerTests
+{
+    private readonly Mock<IOrganizerRepository> _mockRepo;
+    private readonly Mock<IUnitOfWork> _mockUnitOfWork;
+    private readonly CreateOrganizerCommandHandler _handler;
+
+    public CreateOrganizerCommandHandlerTests()
+    {
+        _mockRepo = new Mock<IOrganizerRepository>();
+        _mockUnitOfWork = new Mock<IUnitOfWork>();
+        _handler = new CreateOrganizerCommandHandler(_mockRepo.Object, _mockUnitOfWork.Object);
+    }
+
+    [Fact]
+    public async Task Handle_ValidCommand_ReturnsSuccessWithOrganizerId()
+    {
+        var command = new CreateOrganizerCommand("John Doe", "john@example.com");
+
+        _mockRepo.Setup(r => r.PostAsync(It.IsAny<Organizer>())).ReturnsAsync(Organizer.Create("John Doe", "john@example.com"));
+        _mockUnitOfWork.Setup(u => u.SaveChangesAsync(It.IsAny<CancellationToken>())).ReturnsAsync(1);
+
+        var result = await _handler.Handle(command, CancellationToken.None);
+
+        Assert.True(result.IsSuccess);
+        _mockRepo.Verify(r => r.PostAsync(It.IsAny<Organizer>()), Times.Once);
+    }
+}
diff --git a/EventFlow-API.Tests/Handlers/DeleteEventCommandHandlerTests.cs b/EventFlow-API.Tests/Handlers/DeleteEventCommandHandlerTests.cs
@@ -0,0 +1,53 @@
+using EventFlow.Application.Features.Events.Commands.DeleteEvent;
+using EventFlow.Core.Models;
+using EventFlow.Core.Primitives;
+using EventFlow.Core.Repository;
+using Moq;
+
+namespace EventFlow.Tests.Handlers;
+
+public class DeleteEventCommandHandlerTests
+{
+    private readonly Mock<IEventRepository> _mockRepo;
+    private readonly Mock<IUnitOfWork> _mockUnitOfWork;
+    private readonly Mock<ICacheService> _mockCache;
+    private readonly DeleteEventCommandHandler _handler;
+
+    public DeleteEventCommandHandlerTests()
+    {
+        _mockRepo = new Mock<IEventRepository>();
+        _mockUnitOfWork = new Mock<IUnitOfWork>();
+        _mockCache = new Mock<ICacheService>();
+        _handler = new DeleteEventCommandHandler(_mockRepo.Object, _mockUnitOfWork.Object, _mockCache.Object);
+    }
+
+    [Fact]
+    public async Task Handle_ExistingEvent_ReturnsSuccess()
+    {
+        var existingEvent = Event.Create("Title", "Desc", DateTime.UtcNow.AddDays(2), "Location", 1);
+        var command = new DeleteEventCommand(1);
+
+        _mockRepo.Setup(r => r.GetEventByIdAsync(1)).ReturnsAsync(existingEvent);
+        _mockRepo.Setup(r => r.DeleteAsync(1)).ReturnsAsync(1);
+        _mockUnitOfWork.Setup(u => u.SaveChangesAsync(It.IsAny<CancellationToken>())).ReturnsAsync(1);
+        _mockCache.Setup(c => c.RemoveAsync(It.IsAny<string>())).Returns(Task.CompletedTask);
+
+        var result = await _handler.Handle(command, CancellationToken.None);
+
+        Assert.True(result.IsSuccess);
+        _mockRepo.Verify(r => r.DeleteAsync(1), Times.Once);
+        _mockCache.Verify(c => c.RemoveAsync("event-1"), Times.Once);
+    }
+
+    [Fact]
+    public async Task Handle_NonExistingEvent_ReturnsNotFound()
+    {
+        var command = new DeleteEventCommand(999);
+        _mockRepo.Setup(r => r.GetEventByIdAsync(999)).ReturnsAsync((Event?)null);
+
+        var result = await _handler.Handle(command, CancellationToken.None);
+
+        Assert.True(result.IsFailure);
+        Assert.Equal(ErrorType.NotFound, result.Error.Type);
+    }
+}
diff --git a/EventFlow-API.Tests/Handlers/GetAllEventsQueryHandlerTests.cs b/EventFlow-API.Tests/Handlers/GetAllEventsQueryHandlerTests.cs
@@ -0,0 +1,66 @@
+using EventFlow.Application.DTOs;
+using EventFlow.Application.Features.Events.Queries.GetAllEvents;
+using EventFlow.Core.Models;
+using EventFlow.Core.Repository;
+using Moq;
+using AutoMapper;
+
+namespace EventFlow.Tests.Handlers;
+
+public class GetAllEventsQueryHandlerTests
+{
+    private readonly Mock<IEventRepository> _mockRepo;
+    private readonly Mock<IMapper> _mockMapper;
+    private readonly GetAllEventsQueryHandler _handler;
+
+    public GetAllEventsQueryHandlerTests()
+    {
+        _mockRepo = new Mock<IEventRepository>();
+        _mockMapper = new Mock<IMapper>();
+        _handler = new GetAllEventsQueryHandler(_mockRepo.Object, _mockMapper.Object);
+    }
+
+    [Fact]
+    public async Task Handle_ReturnsPagedResult()
+    {
+        var events = new List<Event>
+        {
+            Event.Create("Event 1", "Desc 1", DateTime.UtcNow.AddDays(2), "Location 1", 1),
+            Event.Create("Event 2", "Desc 2", DateTime.UtcNow.AddDays(3), "Location 2", 1)
+        };
+
+        var pagedResult = new PagedResult<Event>(events, 1, 10, 2);
+        var eventDtos = new List<EventDTO>
+        {
+            new() { Id = 1, Title = "Event 1" },
+            new() { Id = 2, Title = "Event 2" }
+        };
+
+        var query = new GetAllEventsQuery(new QueryParameters { PageNumber = 1, PageSize = 10 });
+
+        _mockRepo.Setup(r => r.GetAllPagedEventsAsync(It.IsAny<QueryParameters>())).ReturnsAsync(pagedResult);
+        _mockMapper.Setup(m => m.Map<List<EventDTO>>(events)).Returns(eventDtos);
+
+        var result = await _handler.Handle(query, CancellationToken.None);
+
+        Assert.Equal(2, result.Items.Count);
+        Assert.Equal(1, result.PageNumber);
+        Assert.Equal(10, result.PageSize);
+        Assert.Equal(2, result.TotalCount);
+    }
+
+    [Fact]
+    public async Task Handle_EmptyResult_ReturnsEmptyList()
+    {
+        var pagedResult = new PagedResult<Event>(new List<Event>(), 1, 10, 0);
+        var query = new GetAllEventsQuery(new QueryParameters { PageNumber = 1, PageSize = 10 });
+
+        _mockRepo.Setup(r => r.GetAllPagedEventsAsync(It.IsAny<QueryParameters>())).ReturnsAsync(pagedResult);
+        _mockMapper.Setup(m => m.Map<List<EventDTO>>(It.IsAny<List<Event>>())).Returns(new List<EventDTO>());
+
+        var result = await _handler.Handle(query, CancellationToken.None);
+
+        Assert.Empty(result.Items);
+        Assert.Equal(0, result.TotalCount);
+    }
+}
diff --git a/EventFlow-API.Tests/Handlers/GetEventByIdQueryHandlerTests.cs b/EventFlow-API.Tests/Handlers/GetEventByIdQueryHandlerTests.cs
@@ -0,0 +1,72 @@
+using EventFlow.Application.DTOs;
+using EventFlow.Application.Features.Events.Queries.GetEventById;
+using EventFlow.Core.Models;
+using EventFlow.Core.Primitives;
+using EventFlow.Core.Repository;
+using Moq;
+using AutoMapper;
+
+namespace EventFlow.Tests.Handlers;
+
+public class GetEventByIdQueryHandlerTests
+{
+    private readonly Mock<IEventRepository> _mockRepo;
+    private readonly Mock<IMapper> _mockMapper;
+    private readonly Mock<ICacheService> _mockCache;
+    private readonly GetEventByIdQueryHandler _handler;
+
+    public GetEventByIdQueryHandlerTests()
+    {
+        _mockRepo = new Mock<IEventRepository>();
+        _mockMapper = new Mock<IMapper>();
+        _mockCache = new Mock<ICacheService>();
+        _handler = new GetEventByIdQueryHandler(_mockRepo.Object, _mockMapper.Object, _mockCache.Object);
+    }
+
+    [Fact]
+    public async Task Handle_CachedResult_ReturnsCachedValue()
+    {
+        var cachedDto = new EventDTO { Id = 1, Title = "Cached Event" };
+        var query = new GetEventByIdQuery(1);
+
+        _mockCache.Setup(c => c.GetAsync<EventDTO>("event-1")).ReturnsAsync(cachedDto);
+
+        var result = await _handler.Handle(query, CancellationToken.None);
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal(cachedDto.Id, result.Value.Id);
+        _mockRepo.Verify(r => r.GetEventByIdAsync(It.IsAny<int>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task Handle_NotCached_ReturnsFromRepository()
+    {
+        var existingEvent = Event.Create("Title", "Desc", DateTime.UtcNow.AddDays(2), "Location", 1);
+        var eventDto = new EventDTO { Id = 1, Title = "Title" };
+        var query = new GetEventByIdQuery(1);
+
+        _mockCache.Setup(c => c.GetAsync<EventDTO>("event-1")).ReturnsAsync((EventDTO?)null);
+        _mockRepo.Setup(r => r.GetEventWithDetailsByIdAsync(1)).ReturnsAsync(existingEvent);
+        _mockMapper.Setup(m => m.Map<EventDTO>(existingEvent)).Returns(eventDto);
+        _mockCache.Setup(c => c.SetAsync(It.IsAny<string>(), It.IsAny<EventDTO>(), It.IsAny<TimeSpan>())).Returns(Task.CompletedTask);
+
+        var result = await _handler.Handle(query, CancellationToken.None);
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal(1, result.Value.Id);
+        _mockCache.Verify(c => c.SetAsync("event-1", eventDto, It.IsAny<TimeSpan>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task Handle_NonExistingEvent_ReturnsNotFound()
+    {
+        var query = new GetEventByIdQuery(999);
+        _mockCache.Setup(c => c.GetAsync<EventDTO>("event-999")).ReturnsAsync((EventDTO?)null);
+        _mockRepo.Setup(r => r.GetEventByIdAsync(999)).ReturnsAsync((Event?)null);
+
+        var result = await _handler.Handle(query, CancellationToken.None);
+
+        Assert.True(result.IsFailure);
+        Assert.Equal(ErrorType.NotFound, result.Error.Type);
+    }
+}
diff --git a/EventFlow-API.Tests/Handlers/GetOrganizerByIdQueryHandlerTests.cs b/EventFlow-API.Tests/Handlers/GetOrganizerByIdQueryHandlerTests.cs
@@ -0,0 +1,56 @@
+using EventFlow.Application.DTOs;
+using EventFlow.Application.Features.Organizers.Queries.GetOrganizerById;
+using EventFlow.Core.Models;
+using EventFlow.Core.Primitives;
+using EventFlow.Core.Repository;
+using Moq;
+using AutoMapper;
+
+namespace EventFlow.Tests.Handlers;
+
+public class GetOrganizerByIdQueryHandlerTests
+{
+    private readonly Mock<IOrganizerRepository> _mockRepo;
+    private readonly Mock<IMapper> _mockMapper;
+    private readonly Mock<ICacheService> _mockCache;
+    private readonly GetOrganizerByIdQueryHandler _handler;
+
+    public GetOrganizerByIdQueryHandlerTests()
+    {
+        _mockRepo = new Mock<IOrganizerRepository>();
+        _mockMapper = new Mock<IMapper>();
+        _mockCache = new Mock<ICacheService>();
+        _handler = new GetOrganizerByIdQueryHandler(_mockRepo.Object, _mockMapper.Object, _mockCache.Object);
+    }
+
+    [Fact]
+    public async Task Handle_ExistingOrganizer_ReturnsOrganizerDto()
+    {
+        var organizer = Organizer.Create("John Doe", "john@example.com");
+        var organizerDto = new OrganizerDTO { Id = 1, Name = "John Doe", Email = "john@example.com" };
+        var query = new GetOrganizerByIdQuery(1);
+
+        _mockCache.Setup(c => c.GetAsync<OrganizerDTO>("organizer-1")).ReturnsAsync((OrganizerDTO?)null);
+        _mockRepo.Setup(r => r.GetOrganizerByIdAsync(1)).ReturnsAsync(organizer);
+        _mockMapper.Setup(m => m.Map<OrganizerDTO>(organizer)).Returns(organizerDto);
+        _mockCache.Setup(c => c.SetAsync(It.IsAny<string>(), It.IsAny<OrganizerDTO>(), It.IsAny<TimeSpan>())).Returns(Task.CompletedTask);
+
+        var result = await _handler.Handle(query, CancellationToken.None);
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal(1, result.Value.Id);
+    }
+
+    [Fact]
+    public async Task Handle_NonExistingOrganizer_ReturnsNotFound()
+    {
+        var query = new GetOrganizerByIdQuery(999);
+        _mockCache.Setup(c => c.GetAsync<OrganizerDTO>("organizer-999")).ReturnsAsync((OrganizerDTO?)null);
+        _mockRepo.Setup(r => r.GetOrganizerByIdAsync(999)).ReturnsAsync((Organizer?)null);
+
+        var result = await _handler.Handle(query, CancellationToken.None);
+
+        Assert.True(result.IsFailure);
+        Assert.Equal(ErrorType.NotFound, result.Error.Type);
+    }
+}
diff --git a/EventFlow-API.Tests/Handlers/UpdateEventCommandHandlerTests.cs b/EventFlow-API.Tests/Handlers/UpdateEventCommandHandlerTests.cs
diff --git a/EventFlow-API.Tests/Primitives/ResultTests.cs b/EventFlow-API.Tests/Primitives/ResultTests.cs
