refactor/cqrs mediatr migration

EventFlow-API.Tests/Controllers/EventControllerTests.cs

@@ -1,123 +1,138 @@
-using Microsoft.AspNetCore.Http;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using EventFlow.Application.Features.Events.Commands.CreateEvent;
+using EventFlow.Application.Features.Events.Commands.DeleteEvent;
+using EventFlow.Application.Features.Events.Commands.UpdateEvent;
+using EventFlow.Application.Features.Events.Queries.GetAllEvents;
+using EventFlow.Application.Features.Events.Queries.GetEventById;
+using EventFlow.Core.Primitives;
 
 namespace EventFlow_API.Tests.Controllers;
 
 public class EventControllerTests
 {
-    private readonly Mock<IEventService> _serviceMock;
     private readonly EventController _controller;
+    private readonly Mock<IMediator> _mockMediator;
 
     public EventControllerTests()
     {
-        _serviceMock = new Mock<IEventService>();
-        _controller = new EventController(_serviceMock.Object);
+        _mockMediator = new Mock<IMediator>();
+        _controller = new EventController(_mockMediator.Object);
         _controller.ControllerContext = new ControllerContext
         {
             HttpContext = new DefaultHttpContext()
         };
     }
 
     [Fact]
-    public async Task PostAsync_ReturnsOk_WhenEventCreated()
+    public async Task Create_ReturnsCreatedAtAction_WhenEventCreated()
     {
-        var command = new EventCommand { Title = "Test", Description = "Test Desc", Date = DateTime.Now, Location = "Test Location", OrganizerId = 1 };
-        var createdEvent = new Event { Id = 1, Title = "Test" };
+        var command = new CreateEventCommand("Test Event", "Description", DateTime.Now.AddDays(1), "Location", 1);
+        var result = Result<int>.Success(1);
 
-        _serviceMock.Setup(s => s.CreateAsync(command)).ReturnsAsync(createdEvent);
+        _mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        var result = await _controller.PostAsync(command);
+        var actionResult = await _controller.Create(command, CancellationToken.None);
 
-        var okResult = Assert.IsType<OkObjectResult>(result);
-        var returnedEvent = Assert.IsType<Event>(okResult.Value);
-        Assert.Equal(1, returnedEvent.Id);
+        var createdResult = Assert.IsType<CreatedAtActionResult>(actionResult);
+        Assert.Equal(1, createdResult.RouteValues!["id"]);
     }
 
     [Fact]
-    public async Task PostAsync_ReturnsBadRequest_WhenCreationFails()
+    public async Task Create_ReturnsError_WhenCreationFails()
     {
-        var command = new EventCommand { Title = "Test", Description = "Test Desc", Date = DateTime.Now, Location = "Test Location", OrganizerId = 1 };
-        _serviceMock.Setup(s => s.CreateAsync(command)).ReturnsAsync((Event)null!);
+        var command = new CreateEventCommand("Test Event", "Description", DateTime.Now.AddDays(1), "Location", 1);
+        var result = Result<int>.Failure(Error.Validation("Event.CreateFailed", "Failed to create event"));
 
-        var result = await _controller.PostAsync(command);
+        _mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        Assert.IsType<BadRequestResult>(result);
+        var actionResult = await _controller.Create(command, CancellationToken.None);
+
+        Assert.IsType<BadRequestObjectResult>(actionResult);
     }
 
     [Fact]
-    public async Task UpdateAsync_ReturnsOk_WhenUpdated()
+    public async Task Update_ReturnsOk_WhenUpdated()
     {
-        var command = new EventCommand { Title = "Updated", Description = "Desc", Date = DateTime.Now, Location = "Loc", OrganizerId = 1 };
-        var updatedEvent = new EventDTO { Id = 1, Title = "Updated" };
+        var command = new UpdateEventCommand(1, "Updated Event", "Description", DateTime.Now.AddDays(1), "Location");
+        var result = Result.Success();
 
-        _serviceMock.Setup(s => s.UpdateAsync(1, command)).ReturnsAsync(updatedEvent);
+        _mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        var result = await _controller.UpdateAsync(1, command);
+        var actionResult = await _controller.Update(1, command, CancellationToken.None);
 
-        var okResult = Assert.IsType<OkObjectResult>(result);
-        var returnedEvent = Assert.IsType<EventDTO>(okResult.Value);
-        Assert.Equal(1, returnedEvent.Id);
+        Assert.IsType<OkResult>(actionResult);
     }
 
     [Fact]
-    public async Task UpdateAsync_ReturnsNotFound_WhenUpdateFails()
+    public async Task Update_ReturnsNotFound_WhenEventNotFound()
     {
-        var command = new EventCommand { Title = "Updated" };
-        _serviceMock.Setup(s => s.UpdateAsync(1, command)).ReturnsAsync((EventDTO)null!);
+        var command = new UpdateEventCommand(1, "Updated Event", "Description", DateTime.Now.AddDays(1), "Location");
+        var result = Result.Failure(Error.NotFound("Event.NotFound", "Event not found"));
+
+        _mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        var result = await _controller.UpdateAsync(1, command);
+        var actionResult = await _controller.Update(1, command, CancellationToken.None);
 
-        Assert.IsType<NotFoundResult>(result);
+        Assert.IsType<NotFoundObjectResult>(actionResult);
     }
 
     [Fact]
-    public async Task DeleteAsync_ReturnsOk_WhenDeleted()
+    public async Task Delete_ReturnsOk_WhenDeleted()
     {
-        _serviceMock.Setup(s => s.DeleteAsync(1)).ReturnsAsync(true);
+        var command = new DeleteEventCommand(1);
+        var result = Result.Success();
+
+        _mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        var result = await _controller.DeleteAsync(1);
+        var actionResult = await _controller.Delete(1, CancellationToken.None);
 
-        var okResult = Assert.IsType<OkObjectResult>(result);
-        Assert.Equal(1, okResult.Value);
+        Assert.IsType<OkResult>(actionResult);
     }
 
     [Fact]
-    public async Task DeleteAsync_ReturnsNotFound_WhenDeleteFails()
+    public async Task Delete_ReturnsNotFound_WhenDeleteFails()
     {
-        _serviceMock.Setup(s => s.DeleteAsync(1)).ReturnsAsync(false);
+        var command = new DeleteEventCommand(1);
+        var result = Result.Failure(Error.NotFound("Event.NotFound", "Event not found"));
 
-        var result = await _controller.DeleteAsync(1);
+        _mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        Assert.IsType<NotFoundResult>(result);
+        var actionResult = await _controller.Delete(1, CancellationToken.None);
+
+        Assert.IsType<NotFoundObjectResult>(actionResult);
     }
 
     [Fact]
     public async Task GetById_ReturnsOk_WhenEventExists()
     {
-        var eventId = 1;
-        var eventDto = new EventDTO { Id = eventId, Title = "Test Event" };
-        _serviceMock.Setup(s => s.GetByIdAsync(eventId)).ReturnsAsync(eventDto);
+        var query = new GetEventByIdQuery(1);
+        var evento = new EventDTO { Id = 1, Title = "Event 1" };
+        var result = Result<EventDTO>.Success(evento);
+
+        _mockMediator.Setup(m => m.Send(query, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        var result = await _controller.GetEventByIdAsync(eventId);
+        var actionResult = await _controller.GetById(1, CancellationToken.None);
 
-        var okResult = Assert.IsType<OkObjectResult>(result);
+        var okResult = Assert.IsType<OkObjectResult>(actionResult);
         var returnValue = Assert.IsType<EventDTO>(okResult.Value);
-        Assert.Equal(eventDto.Id, returnValue.Id);
+        returnValue.Id.Should().Be(1);
     }
 
     [Fact]
-    public async Task GetAllEventsAsync_ReturnsNotFound_WhenNoEventsExist()
+    public async Task GetAll_ReturnsOk_WithList()
     {
         var queryParameters = new QueryParameters();
-        var emptyList = new List<EventDTO>();
-
-        var pagedResult = new PagedResult<EventDTO>(emptyList, 1, 10, 0);
+        var query = new GetAllEventsQuery(queryParameters);
+        var events = new List<EventDTO> { new() { Id = 1, Title = "Event 1" } };
+        var pagedResult = new PagedResult<EventDTO>(events, 1, 10, 1);
 
-        _serviceMock
-            .Setup(s => s.GetAllPagedEventsAsync(It.IsAny<QueryParameters>()))
-            .ReturnsAsync(pagedResult);
+        _mockMediator.Setup(m => m.Send(query, It.IsAny<CancellationToken>())).ReturnsAsync(pagedResult);
 
-        var result = await _controller.GetAllEventsAsync(queryParameters);
+        var actionResult = await _controller.GetAll(queryParameters, CancellationToken.None);
 
-        Assert.IsType<NotFoundResult>(result);
+        var okResult = Assert.IsType<OkObjectResult>(actionResult);
+        var returnValue = Assert.IsType<List<EventDTO>>(okResult.Value);
+        returnValue.Should().HaveCount(1);
     }
 }

EventFlow-API.Tests/Controllers/OrganizerControllerTests.cs

@@ -1,16 +1,23 @@
-using Microsoft.AspNetCore.Http;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using EventFlow.Application.Features.Organizers.Commands.CreateOrganizer;
+using EventFlow.Application.Features.Organizers.Commands.DeleteOrganizer;
+using EventFlow.Application.Features.Organizers.Commands.UpdateOrganizer;
+using EventFlow.Application.Features.Organizers.Queries.GetAllOrganizers;
+using EventFlow.Application.Features.Organizers.Queries.GetOrganizerById;
+using EventFlow.Core.Primitives;
 
 namespace EventFlow_API.Tests.Controllers;
 
 public class OrganizerControllerTests
 {
     private readonly OrganizerController _controller;
-    private readonly Mock<IOrganizerService> _mockService;
+    private readonly Mock<ISender> _mockSender;
 
     public OrganizerControllerTests()
     {
-        _mockService = new Mock<IOrganizerService>();
-        _controller = new OrganizerController(_mockService.Object);
+        _mockSender = new Mock<ISender>();
+        _controller = new OrganizerController(_mockSender.Object);
         _controller.ControllerContext = new ControllerContext
         {
             HttpContext = new DefaultHttpContext()
@@ -20,107 +27,94 @@ public OrganizerControllerTests()
     [Fact]
     public async Task PostAsync_ReturnsOk_WhenOrganizerCreated()
     {
-        var command = new OrganizerCommand { Name = "Test", Email = "test@example.com" };
-        var organizer = new Organizer { Id = 1, Name = "Test", Email = "test@example.com" };
+        var command = new CreateOrganizerCommand("Test", "test@example.com");
+        var result = Result<int>.Success(1);
 
-        _mockService.Setup(s => s.CreateAsync(command)).ReturnsAsync(organizer);
+        _mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        var result = await _controller.PostAsync(command);
+        var actionResult = await _controller.PostAsync(command);
 
-        var okResult = Assert.IsType<OkObjectResult>(result);
-        var returnValue = Assert.IsType<Organizer>(okResult.Value);
-        returnValue.Id.Should().Be(1);
+        var okResult = Assert.IsType<OkObjectResult>(actionResult);
+        Assert.Equal(1, okResult.Value);
     }
 
     [Fact]
     public async Task PostAsync_ReturnsBadRequest_WhenCreationFails()
     {
-        var command = new OrganizerCommand { Name = "Test", Email = "test@example.com" };
+        var command = new CreateOrganizerCommand("Test", "test@example.com");
+        var result = Result<int>.Failure(Error.Validation("Organizer.CreateFailed", "Failed to create organizer"));
 
-        _mockService.Setup(s => s.CreateAsync(command)).ReturnsAsync((Organizer)null!);
+        _mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        var result = await _controller.PostAsync(command);
+        var actionResult = await _controller.PostAsync(command);
 
-        Assert.IsType<BadRequestResult>(result);
+        Assert.IsType<BadRequestObjectResult>(actionResult);
     }
 
     [Fact]
     public async Task UpdateAsync_ReturnsOk_WhenUpdated()
     {
-        var command = new OrganizerCommand { Name = "Updated", Email = "updated@example.com" };
-        var updated = new OrganizerDTO { Id = 1, Name = "Updated" };
+        var command = new UpdateOrganizerCommand(1, "Updated", "updated@example.com");
+        var result = Result.Success();
 
-        _mockService.Setup(s => s.UpdateAsync(1, command)).ReturnsAsync(updated);
+        _mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        var result = await _controller.UpdateAsync(1, command);
+        var actionResult = await _controller.UpdateAsync(1, command);
 
-        var okResult = Assert.IsType<OkObjectResult>(result);
-        var returnValue = Assert.IsType<OrganizerDTO>(okResult.Value);
-        returnValue.Id.Should().Be(1);
+        Assert.IsType<OkResult>(actionResult);
     }
 
     [Fact]
-    public async Task UpdateAsync_ReturnsNotFound_WhenUpdateFails()
+    public async Task UpdateAsync_ReturnsNotFound_WhenOrganizerNotFound()
     {
-        var command = new OrganizerCommand { Name = "Updated", Email = "updated@example.com" };
+        var command = new UpdateOrganizerCommand(1, "Updated", "updated@example.com");
+        var result = Result.Failure(Error.NotFound("Organizer.NotFound", "Organizer not found"));
 
-        _mockService.Setup(s => s.UpdateAsync(1, command)).ReturnsAsync((OrganizerDTO)null!);
+        _mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        var result = await _controller.UpdateAsync(1, command);
+        var actionResult = await _controller.UpdateAsync(1, command);
 
-        Assert.IsType<NotFoundResult>(result);
+        Assert.IsType<NotFoundObjectResult>(actionResult);
     }
 
     [Fact]
     public async Task DeleteAsync_ReturnsOk_WhenDeleted()
     {
-        _mockService.Setup(s => s.DeleteAsync(1)).ReturnsAsync(true);
-
-        var result = await _controller.DeleteAsync(1);
+        var command = new DeleteOrganizerCommand(1);
+        var result = Result.Success();
 
-        var okResult = Assert.IsType<OkObjectResult>(result);
-        Assert.Equal(1, okResult.Value);
-    }
+        _mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-    [Fact]
-    public async Task DeleteAsync_ReturnsNotFound_WhenDeleteFails()
-    {
-        _mockService.Setup(s => s.DeleteAsync(1)).ReturnsAsync(false);
+        var actionResult = await _controller.DeleteAsync(1);
 
-        var result = await _controller.DeleteAsync(1);
-
-        Assert.IsType<NotFoundResult>(result);
+        Assert.IsType<OkResult>(actionResult);
     }
 
     [Fact]
-    public async Task RegisterParticipantAsync_ReturnsOk_WhenSuccess()
+    public async Task DeleteAsync_ReturnsNotFound_WhenDeleteFails()
     {
-        _mockService.Setup(s => s.RegisterToEventAsync(1, 1)).ReturnsAsync(true);
+        var command = new DeleteOrganizerCommand(1);
+        var result = Result.Failure(Error.NotFound("Organizer.NotFound", "Organizer not found"));
 
-        var result = await _controller.RegisterParticipantAsync(1, 1);
+        _mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        var okResult = Assert.IsType<OkObjectResult>(result);
-    }
+        var actionResult = await _controller.DeleteAsync(1);
 
-    [Fact]
-    public async Task RegisterParticipantAsync_ReturnsNotFound_WhenFailure()
-    {
-        _mockService.Setup(s => s.RegisterToEventAsync(1, 1)).ReturnsAsync(false);
-
-        var result = await _controller.RegisterParticipantAsync(1, 1);
-
-        var notFoundResult = Assert.IsType<NotFoundObjectResult>(result);
+        Assert.IsType<NotFoundObjectResult>(actionResult);
     }
 
     [Fact]
     public async Task GetById_ReturnsOk_WhenOrganizerExists()
     {
+        var query = new GetOrganizerByIdQuery(1);
         var organizer = new OrganizerDTO { Id = 1, Name = "Organizer 1" };
-        _mockService.Setup(s => s.GetByIdAsync(1)).ReturnsAsync(organizer);
+        var result = Result<OrganizerDTO>.Success(organizer);
 
-        var result = await _controller.GetOrganizerByIdAsync(1);
+        _mockSender.Setup(s => s.Send(query, It.IsAny<CancellationToken>())).ReturnsAsync(result);
 
-        var okResult = Assert.IsType<OkObjectResult>(result);
+        var actionResult = await _controller.GetOrganizerByIdAsync(1);
+
+        var okResult = Assert.IsType<OkObjectResult>(actionResult);
         var returnValue = Assert.IsType<OrganizerDTO>(okResult.Value);
         returnValue.Id.Should().Be(1);
     }
@@ -129,18 +123,16 @@ public async Task GetById_ReturnsOk_WhenOrganizerExists()
     public async Task GetAll_ReturnsOk_WithList()
     {
         var queryParameters = new QueryParameters();
+        var query = new GetAllOrganizersQuery(queryParameters);
         var organizers = new List<OrganizerDTO> { new() { Id = 1, Name = "Organizer 1" } };
         var pagedResult = new PagedResult<OrganizerDTO>(organizers, 1, 10, 1);
 
-        _mockService
-            .Setup(s => s.GetAllPagedOrganizersAsync(It.IsAny<QueryParameters>()))
-            .ReturnsAsync(pagedResult);
+        _mockSender.Setup(s => s.Send(query, It.IsAny<CancellationToken>())).ReturnsAsync(pagedResult);
 
-        var result = await _controller.GetAllOrganizersAsync(queryParameters);
+        var actionResult = await _controller.GetAllOrganizersAsync(queryParameters);
 
-        var okResult = Assert.IsType<OkObjectResult>(result);
+        var okResult = Assert.IsType<OkObjectResult>(actionResult);
         var returnValue = Assert.IsType<List<OrganizerDTO>>(okResult.Value);
         returnValue.Should().HaveCount(1);
     }
-
 }