Skip to content

Commit dc4cc5d

Browse files
alysonszalysonsz
authored
Merge PR #1: refactor/cqrs mediatr migration
2 parents 04dd21f + 2cca2c1 commit dc4cc5d

154 files changed

Lines changed: 3386 additions & 2415 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎EventFlow-API.Tests/Controllers/EventControllerTests.cs‎

Lines changed: 69 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -1,123 +1,138 @@
1-
using Microsoft.AspNetCore.Http;
1+
using MediatR;
2+
using Microsoft.AspNetCore.Http;
3+
using EventFlow.Application.Features.Events.Commands.CreateEvent;
4+
using EventFlow.Application.Features.Events.Commands.DeleteEvent;
5+
using EventFlow.Application.Features.Events.Commands.UpdateEvent;
6+
using EventFlow.Application.Features.Events.Queries.GetAllEvents;
7+
using EventFlow.Application.Features.Events.Queries.GetEventById;
8+
using EventFlow.Core.Primitives;
29

310
namespace EventFlow_API.Tests.Controllers;
411

512
public class EventControllerTests
613
{
7-
private readonly Mock<IEventService> _serviceMock;
814
private readonly EventController _controller;
15+
private readonly Mock<IMediator> _mockMediator;
916

1017
public EventControllerTests()
1118
{
12-
_serviceMock = new Mock<IEventService>();
13-
_controller = new EventController(_serviceMock.Object);
19+
_mockMediator = new Mock<IMediator>();
20+
_controller = new EventController(_mockMediator.Object);
1421
_controller.ControllerContext = new ControllerContext
1522
{
1623
HttpContext = new DefaultHttpContext()
1724
};
1825
}
1926

2027
[Fact]
21-
public async Task PostAsync_ReturnsOk_WhenEventCreated()
28+
public async Task Create_ReturnsCreatedAtAction_WhenEventCreated()
2229
{
23-
var command = new EventCommand { Title = "Test", Description = "Test Desc", Date = DateTime.Now, Location = "Test Location", OrganizerId = 1 };
24-
var createdEvent = new Event { Id = 1, Title = "Test" };
30+
var command = new CreateEventCommand("Test Event", "Description", DateTime.Now.AddDays(1), "Location", 1);
31+
var result = Result<int>.Success(1);
2532

26-
_serviceMock.Setup(s => s.CreateAsync(command)).ReturnsAsync(createdEvent);
33+
_mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
2734

28-
var result = await _controller.PostAsync(command);
35+
var actionResult = await _controller.Create(command, CancellationToken.None);
2936

30-
var okResult = Assert.IsType<OkObjectResult>(result);
31-
var returnedEvent = Assert.IsType<Event>(okResult.Value);
32-
Assert.Equal(1, returnedEvent.Id);
37+
var createdResult = Assert.IsType<CreatedAtActionResult>(actionResult);
38+
Assert.Equal(1, createdResult.RouteValues!["id"]);
3339
}
3440

3541
[Fact]
36-
public async Task PostAsync_ReturnsBadRequest_WhenCreationFails()
42+
public async Task Create_ReturnsError_WhenCreationFails()
3743
{
38-
var command = new EventCommand { Title = "Test", Description = "Test Desc", Date = DateTime.Now, Location = "Test Location", OrganizerId = 1 };
39-
_serviceMock.Setup(s => s.CreateAsync(command)).ReturnsAsync((Event)null!);
44+
var command = new CreateEventCommand("Test Event", "Description", DateTime.Now.AddDays(1), "Location", 1);
45+
var result = Result<int>.Failure(Error.Validation("Event.CreateFailed", "Failed to create event"));
4046

41-
var result = await _controller.PostAsync(command);
47+
_mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
4248

43-
Assert.IsType<BadRequestResult>(result);
49+
var actionResult = await _controller.Create(command, CancellationToken.None);
50+
51+
Assert.IsType<BadRequestObjectResult>(actionResult);
4452
}
4553

4654
[Fact]
47-
public async Task UpdateAsync_ReturnsOk_WhenUpdated()
55+
public async Task Update_ReturnsOk_WhenUpdated()
4856
{
49-
var command = new EventCommand { Title = "Updated", Description = "Desc", Date = DateTime.Now, Location = "Loc", OrganizerId = 1 };
50-
var updatedEvent = new EventDTO { Id = 1, Title = "Updated" };
57+
var command = new UpdateEventCommand(1, "Updated Event", "Description", DateTime.Now.AddDays(1), "Location");
58+
var result = Result.Success();
5159

52-
_serviceMock.Setup(s => s.UpdateAsync(1, command)).ReturnsAsync(updatedEvent);
60+
_mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
5361

54-
var result = await _controller.UpdateAsync(1, command);
62+
var actionResult = await _controller.Update(1, command, CancellationToken.None);
5563

56-
var okResult = Assert.IsType<OkObjectResult>(result);
57-
var returnedEvent = Assert.IsType<EventDTO>(okResult.Value);
58-
Assert.Equal(1, returnedEvent.Id);
64+
Assert.IsType<OkResult>(actionResult);
5965
}
6066

6167
[Fact]
62-
public async Task UpdateAsync_ReturnsNotFound_WhenUpdateFails()
68+
public async Task Update_ReturnsNotFound_WhenEventNotFound()
6369
{
64-
var command = new EventCommand { Title = "Updated" };
65-
_serviceMock.Setup(s => s.UpdateAsync(1, command)).ReturnsAsync((EventDTO)null!);
70+
var command = new UpdateEventCommand(1, "Updated Event", "Description", DateTime.Now.AddDays(1), "Location");
71+
var result = Result.Failure(Error.NotFound("Event.NotFound", "Event not found"));
72+
73+
_mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
6674

67-
var result = await _controller.UpdateAsync(1, command);
75+
var actionResult = await _controller.Update(1, command, CancellationToken.None);
6876

69-
Assert.IsType<NotFoundResult>(result);
77+
Assert.IsType<NotFoundObjectResult>(actionResult);
7078
}
7179

7280
[Fact]
73-
public async Task DeleteAsync_ReturnsOk_WhenDeleted()
81+
public async Task Delete_ReturnsOk_WhenDeleted()
7482
{
75-
_serviceMock.Setup(s => s.DeleteAsync(1)).ReturnsAsync(true);
83+
var command = new DeleteEventCommand(1);
84+
var result = Result.Success();
85+
86+
_mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
7687

77-
var result = await _controller.DeleteAsync(1);
88+
var actionResult = await _controller.Delete(1, CancellationToken.None);
7889

79-
var okResult = Assert.IsType<OkObjectResult>(result);
80-
Assert.Equal(1, okResult.Value);
90+
Assert.IsType<OkResult>(actionResult);
8191
}
8292

8393
[Fact]
84-
public async Task DeleteAsync_ReturnsNotFound_WhenDeleteFails()
94+
public async Task Delete_ReturnsNotFound_WhenDeleteFails()
8595
{
86-
_serviceMock.Setup(s => s.DeleteAsync(1)).ReturnsAsync(false);
96+
var command = new DeleteEventCommand(1);
97+
var result = Result.Failure(Error.NotFound("Event.NotFound", "Event not found"));
8798

88-
var result = await _controller.DeleteAsync(1);
99+
_mockMediator.Setup(m => m.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
89100

90-
Assert.IsType<NotFoundResult>(result);
101+
var actionResult = await _controller.Delete(1, CancellationToken.None);
102+
103+
Assert.IsType<NotFoundObjectResult>(actionResult);
91104
}
92105

93106
[Fact]
94107
public async Task GetById_ReturnsOk_WhenEventExists()
95108
{
96-
var eventId = 1;
97-
var eventDto = new EventDTO { Id = eventId, Title = "Test Event" };
98-
_serviceMock.Setup(s => s.GetByIdAsync(eventId)).ReturnsAsync(eventDto);
109+
var query = new GetEventByIdQuery(1);
110+
var evento = new EventDTO { Id = 1, Title = "Event 1" };
111+
var result = Result<EventDTO>.Success(evento);
112+
113+
_mockMediator.Setup(m => m.Send(query, It.IsAny<CancellationToken>())).ReturnsAsync(result);
99114

100-
var result = await _controller.GetEventByIdAsync(eventId);
115+
var actionResult = await _controller.GetById(1, CancellationToken.None);
101116

102-
var okResult = Assert.IsType<OkObjectResult>(result);
117+
var okResult = Assert.IsType<OkObjectResult>(actionResult);
103118
var returnValue = Assert.IsType<EventDTO>(okResult.Value);
104-
Assert.Equal(eventDto.Id, returnValue.Id);
119+
returnValue.Id.Should().Be(1);
105120
}
106121

107122
[Fact]
108-
public async Task GetAllEventsAsync_ReturnsNotFound_WhenNoEventsExist()
123+
public async Task GetAll_ReturnsOk_WithList()
109124
{
110125
var queryParameters = new QueryParameters();
111-
var emptyList = new List<EventDTO>();
112-
113-
var pagedResult = new PagedResult<EventDTO>(emptyList, 1, 10, 0);
126+
var query = new GetAllEventsQuery(queryParameters);
127+
var events = new List<EventDTO> { new() { Id = 1, Title = "Event 1" } };
128+
var pagedResult = new PagedResult<EventDTO>(events, 1, 10, 1);
114129

115-
_serviceMock
116-
.Setup(s => s.GetAllPagedEventsAsync(It.IsAny<QueryParameters>()))
117-
.ReturnsAsync(pagedResult);
130+
_mockMediator.Setup(m => m.Send(query, It.IsAny<CancellationToken>())).ReturnsAsync(pagedResult);
118131

119-
var result = await _controller.GetAllEventsAsync(queryParameters);
132+
var actionResult = await _controller.GetAll(queryParameters, CancellationToken.None);
120133

121-
Assert.IsType<NotFoundResult>(result);
134+
var okResult = Assert.IsType<OkObjectResult>(actionResult);
135+
var returnValue = Assert.IsType<List<EventDTO>>(okResult.Value);
136+
returnValue.Should().HaveCount(1);
122137
}
123138
}

‎EventFlow-API.Tests/Controllers/OrganizerControllerTests.cs‎

Lines changed: 54 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,23 @@
1-
using Microsoft.AspNetCore.Http;
1+
using MediatR;
2+
using Microsoft.AspNetCore.Http;
3+
using EventFlow.Application.Features.Organizers.Commands.CreateOrganizer;
4+
using EventFlow.Application.Features.Organizers.Commands.DeleteOrganizer;
5+
using EventFlow.Application.Features.Organizers.Commands.UpdateOrganizer;
6+
using EventFlow.Application.Features.Organizers.Queries.GetAllOrganizers;
7+
using EventFlow.Application.Features.Organizers.Queries.GetOrganizerById;
8+
using EventFlow.Core.Primitives;
29

310
namespace EventFlow_API.Tests.Controllers;
411

512
public class OrganizerControllerTests
613
{
714
private readonly OrganizerController _controller;
8-
private readonly Mock<IOrganizerService> _mockService;
15+
private readonly Mock<ISender> _mockSender;
916

1017
public OrganizerControllerTests()
1118
{
12-
_mockService = new Mock<IOrganizerService>();
13-
_controller = new OrganizerController(_mockService.Object);
19+
_mockSender = new Mock<ISender>();
20+
_controller = new OrganizerController(_mockSender.Object);
1421
_controller.ControllerContext = new ControllerContext
1522
{
1623
HttpContext = new DefaultHttpContext()
@@ -20,107 +27,94 @@ public OrganizerControllerTests()
2027
[Fact]
2128
public async Task PostAsync_ReturnsOk_WhenOrganizerCreated()
2229
{
23-
var command = new OrganizerCommand { Name = "Test", Email = "test@example.com" };
24-
var organizer = new Organizer { Id = 1, Name = "Test", Email = "test@example.com" };
30+
var command = new CreateOrganizerCommand("Test", "test@example.com");
31+
var result = Result<int>.Success(1);
2532

26-
_mockService.Setup(s => s.CreateAsync(command)).ReturnsAsync(organizer);
33+
_mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
2734

28-
var result = await _controller.PostAsync(command);
35+
var actionResult = await _controller.PostAsync(command);
2936

30-
var okResult = Assert.IsType<OkObjectResult>(result);
31-
var returnValue = Assert.IsType<Organizer>(okResult.Value);
32-
returnValue.Id.Should().Be(1);
37+
var okResult = Assert.IsType<OkObjectResult>(actionResult);
38+
Assert.Equal(1, okResult.Value);
3339
}
3440

3541
[Fact]
3642
public async Task PostAsync_ReturnsBadRequest_WhenCreationFails()
3743
{
38-
var command = new OrganizerCommand { Name = "Test", Email = "test@example.com" };
44+
var command = new CreateOrganizerCommand("Test", "test@example.com");
45+
var result = Result<int>.Failure(Error.Validation("Organizer.CreateFailed", "Failed to create organizer"));
3946

40-
_mockService.Setup(s => s.CreateAsync(command)).ReturnsAsync((Organizer)null!);
47+
_mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
4148

42-
var result = await _controller.PostAsync(command);
49+
var actionResult = await _controller.PostAsync(command);
4350

44-
Assert.IsType<BadRequestResult>(result);
51+
Assert.IsType<BadRequestObjectResult>(actionResult);
4552
}
4653

4754
[Fact]
4855
public async Task UpdateAsync_ReturnsOk_WhenUpdated()
4956
{
50-
var command = new OrganizerCommand { Name = "Updated", Email = "updated@example.com" };
51-
var updated = new OrganizerDTO { Id = 1, Name = "Updated" };
57+
var command = new UpdateOrganizerCommand(1, "Updated", "updated@example.com");
58+
var result = Result.Success();
5259

53-
_mockService.Setup(s => s.UpdateAsync(1, command)).ReturnsAsync(updated);
60+
_mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
5461

55-
var result = await _controller.UpdateAsync(1, command);
62+
var actionResult = await _controller.UpdateAsync(1, command);
5663

57-
var okResult = Assert.IsType<OkObjectResult>(result);
58-
var returnValue = Assert.IsType<OrganizerDTO>(okResult.Value);
59-
returnValue.Id.Should().Be(1);
64+
Assert.IsType<OkResult>(actionResult);
6065
}
6166

6267
[Fact]
63-
public async Task UpdateAsync_ReturnsNotFound_WhenUpdateFails()
68+
public async Task UpdateAsync_ReturnsNotFound_WhenOrganizerNotFound()
6469
{
65-
var command = new OrganizerCommand { Name = "Updated", Email = "updated@example.com" };
70+
var command = new UpdateOrganizerCommand(1, "Updated", "updated@example.com");
71+
var result = Result.Failure(Error.NotFound("Organizer.NotFound", "Organizer not found"));
6672

67-
_mockService.Setup(s => s.UpdateAsync(1, command)).ReturnsAsync((OrganizerDTO)null!);
73+
_mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
6874

69-
var result = await _controller.UpdateAsync(1, command);
75+
var actionResult = await _controller.UpdateAsync(1, command);
7076

71-
Assert.IsType<NotFoundResult>(result);
77+
Assert.IsType<NotFoundObjectResult>(actionResult);
7278
}
7379

7480
[Fact]
7581
public async Task DeleteAsync_ReturnsOk_WhenDeleted()
7682
{
77-
_mockService.Setup(s => s.DeleteAsync(1)).ReturnsAsync(true);
78-
79-
var result = await _controller.DeleteAsync(1);
83+
var command = new DeleteOrganizerCommand(1);
84+
var result = Result.Success();
8085

81-
var okResult = Assert.IsType<OkObjectResult>(result);
82-
Assert.Equal(1, okResult.Value);
83-
}
86+
_mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
8487

85-
[Fact]
86-
public async Task DeleteAsync_ReturnsNotFound_WhenDeleteFails()
87-
{
88-
_mockService.Setup(s => s.DeleteAsync(1)).ReturnsAsync(false);
88+
var actionResult = await _controller.DeleteAsync(1);
8989

90-
var result = await _controller.DeleteAsync(1);
91-
92-
Assert.IsType<NotFoundResult>(result);
90+
Assert.IsType<OkResult>(actionResult);
9391
}
9492

9593
[Fact]
96-
public async Task RegisterParticipantAsync_ReturnsOk_WhenSuccess()
94+
public async Task DeleteAsync_ReturnsNotFound_WhenDeleteFails()
9795
{
98-
_mockService.Setup(s => s.RegisterToEventAsync(1, 1)).ReturnsAsync(true);
96+
var command = new DeleteOrganizerCommand(1);
97+
var result = Result.Failure(Error.NotFound("Organizer.NotFound", "Organizer not found"));
9998

100-
var result = await _controller.RegisterParticipantAsync(1, 1);
99+
_mockSender.Setup(s => s.Send(command, It.IsAny<CancellationToken>())).ReturnsAsync(result);
101100

102-
var okResult = Assert.IsType<OkObjectResult>(result);
103-
}
101+
var actionResult = await _controller.DeleteAsync(1);
104102

105-
[Fact]
106-
public async Task RegisterParticipantAsync_ReturnsNotFound_WhenFailure()
107-
{
108-
_mockService.Setup(s => s.RegisterToEventAsync(1, 1)).ReturnsAsync(false);
109-
110-
var result = await _controller.RegisterParticipantAsync(1, 1);
111-
112-
var notFoundResult = Assert.IsType<NotFoundObjectResult>(result);
103+
Assert.IsType<NotFoundObjectResult>(actionResult);
113104
}
114105

115106
[Fact]
116107
public async Task GetById_ReturnsOk_WhenOrganizerExists()
117108
{
109+
var query = new GetOrganizerByIdQuery(1);
118110
var organizer = new OrganizerDTO { Id = 1, Name = "Organizer 1" };
119-
_mockService.Setup(s => s.GetByIdAsync(1)).ReturnsAsync(organizer);
111+
var result = Result<OrganizerDTO>.Success(organizer);
120112

121-
var result = await _controller.GetOrganizerByIdAsync(1);
113+
_mockSender.Setup(s => s.Send(query, It.IsAny<CancellationToken>())).ReturnsAsync(result);
122114

123-
var okResult = Assert.IsType<OkObjectResult>(result);
115+
var actionResult = await _controller.GetOrganizerByIdAsync(1);
116+
117+
var okResult = Assert.IsType<OkObjectResult>(actionResult);
124118
var returnValue = Assert.IsType<OrganizerDTO>(okResult.Value);
125119
returnValue.Id.Should().Be(1);
126120
}
@@ -129,18 +123,16 @@ public async Task GetById_ReturnsOk_WhenOrganizerExists()
129123
public async Task GetAll_ReturnsOk_WithList()
130124
{
131125
var queryParameters = new QueryParameters();
126+
var query = new GetAllOrganizersQuery(queryParameters);
132127
var organizers = new List<OrganizerDTO> { new() { Id = 1, Name = "Organizer 1" } };
133128
var pagedResult = new PagedResult<OrganizerDTO>(organizers, 1, 10, 1);
134129

135-
_mockService
136-
.Setup(s => s.GetAllPagedOrganizersAsync(It.IsAny<QueryParameters>()))
137-
.ReturnsAsync(pagedResult);
130+
_mockSender.Setup(s => s.Send(query, It.IsAny<CancellationToken>())).ReturnsAsync(pagedResult);
138131

139-
var result = await _controller.GetAllOrganizersAsync(queryParameters);
132+
var actionResult = await _controller.GetAllOrganizersAsync(queryParameters);
140133

141-
var okResult = Assert.IsType<OkObjectResult>(result);
134+
var okResult = Assert.IsType<OkObjectResult>(actionResult);
142135
var returnValue = Assert.IsType<List<OrganizerDTO>>(okResult.Value);
143136
returnValue.Should().HaveCount(1);
144137
}
145-
146138
}

0 commit comments

Comments
 (0)