feat(Tests): add Application integration tests and some fix and refactor

.github/workflows/build.yml

@@ -48,6 +48,11 @@ jobs:
     - name: Test solution
       run: dotnet test --no-build --configuration Release --filter "FullyQualifiedName!~AcceptanceTests"
 
+    - name: Analyze with SonarCloud
+      uses: sonarsource/[email protected]
+      env:
+        SONAR_TOKEN: ${{ secrets.SONARCLOUND_TOKEN }}
+
     - name: Publish website
       if: ${{ inputs.build-artifacts == true }}
       run: |

.github/workflows/codeql.yml

@@ -36,8 +36,6 @@ jobs:
 
     - name: Autobuild
       uses: github/codeql-action/autobuild@v2
-      env:
-        SkipNSwag: True
 
     - name: Perform CodeQL Analysis
       uses: github/codeql-action/analyze@v2

README.md

@@ -87,7 +87,7 @@ The template includes a full CI/CD pipeline. The pipeline is responsible for bui
 * [Maspter](https://github.com/MapsterMapper/Mapster)
 * [FluentResult](https://github.com/altmann/FluentResults)
 * [FluentValidation](https://fluentvalidation.net/)
-* [NUnit](https://nunit.org/), [FluentAssertions](https://fluentassertions.com/), [NetArchTest.Rules](https://github.com/BenMorris/NetArchTest), [Moq](https://github.com/devlooped/moq) & [Respawn](https://github.com/jbogard/Respawn)
+* [NUnit](https://nunit.org/), [FluentAssertions](https://fluentassertions.com/), [NetArchTest.Rules](https://github.com/BenMorris/NetArchTest), [TestContainer](https://dotnet.testcontainers.org/) & [Moq](https://github.com/devlooped/moq)
 
 ## Versions
 The main branch is now on .NET 8.0.

docker-compose.dcproj

@@ -7,7 +7,7 @@
     <DockerLaunchAction>LaunchBrowser</DockerLaunchAction>
     <DockerServiceUrl>{Scheme}://localhost:{ServicePort}/swagger</DockerServiceUrl>
     <DockerServiceName>api</DockerServiceName>
-    <DockerComposeProjectName>FastCleanArchitecture</DockerComposeProjectName>
+    <DockerComposeProjectName>fast-clean-architecture</DockerComposeProjectName>
   </PropertyGroup>
   <ItemGroup>
     <None Include="docker-compose.override.yml">

docker-compose.override.yml

@@ -1,7 +1,7 @@
 version: '3.4'
 
 services:
-  web-api:
+  api:
     environment:
       - ASPNETCORE_ENVIRONMENT=Development
       - ASPNETCORE_HTTP_PORTS=8080

src/Application/TodoItems/Commands/DeleteTodoItem/DeleteTodoItem.cs

@@ -2,7 +2,6 @@
 using FastCleanArchitecture.Domain.Common;
 using FastCleanArchitecture.Domain.TodoItems;
 using FluentResults;
-using MediatR;
 
 namespace FastCleanArchitecture.Application.TodoItems.Commands.DeleteTodoItem;
 

src/Application/TodoLists/Commands/Update/UpdateTodoListCommandValidator.cs

@@ -23,6 +23,7 @@ public UpdateTodoListCommandValidator(ITodoListRepository todoListRepository)
     public async Task<bool> BeUniqueTitle(UpdateTodoListCommand request, string title, CancellationToken cancellationToken)
     {
         var entity = await _todoListRepository.GetByIdAsync(request.Id, cancellationToken);
-        return entity is not null && entity!.Title!.Equals(title, StringComparison.OrdinalIgnoreCase);
+
+        return entity is null || !entity!.Title!.Equals(title, StringComparison.OrdinalIgnoreCase);
     }
 }

src/Domain/TodoItems/TodoItem.cs

@@ -44,6 +44,7 @@ public static TodoItem Update(string? title, bool Done, TodoItem todoItem)
     {
         todoItem.Title = title;
         todoItem.Done = Done;
+        todoItem.ModifiedAtUtc = DateTime.UtcNow;
         return todoItem;
     }
 
@@ -52,6 +53,7 @@ public static TodoItem UpdateDetail(Guid listId, PriorityLevel priority, string?
         todoItem.ListId = listId;
         todoItem.Priority = priority;
         todoItem.Note = note;
+        todoItem.ModifiedAtUtc = DateTime.UtcNow;
         return todoItem;
     }
 }

tests/Application.IntegrationTests/Infrastructure/BaseIntegrationTest.cs

@@ -1,5 +1,6 @@
 using FastCleanArchitecture.Infrastructure.Data;
 using MediatR;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Application.IntegrationTests.Infrastructure;
@@ -32,4 +33,18 @@ public async Task OneTimeTearDown()
         _scope.Dispose();
         DbContext.Dispose();
     }
+
+    protected async Task<TEntity?> FindAsync<TEntity>(params object[] keyValues) where TEntity : class
+    {
+        var context = _scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
+
+        return await context.FindAsync<TEntity>(keyValues);
+    }
+
+    protected async Task<int> CountAsync<TEntity>() where TEntity : class
+    {
+        var context = _scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
+
+        return await context.Set<TEntity>().CountAsync();
+    }
 }

tests/Application.IntegrationTests/TodoItems/Commands/CreateTodoItemTests.cs

@@ -0,0 +1,46 @@
+using Application.IntegrationTests.Infrastructure;
+using FastCleanArchitecture.Application.Common.Exceptions;
+using FastCleanArchitecture.Application.TodoItems.Commands.CreateTodoItem;
+using FastCleanArchitecture.Application.TodoLists.Commands.Create;
+using FastCleanArchitecture.Domain.TodoItems;
+using FluentAssertions;
+
+namespace Application.IntegrationTests.TodoItems.Commands;
+
+internal sealed class CreateTodoItemTests : BaseIntegrationTest
+{
+    [Test]
+    public async Task CreateTodoItem_ShouldThrowValidation_WhenRequireMinimumFields()
+    {
+        // Arrange
+        var command = new CreateTodoItemCommand();
+
+        // Act & Assert
+        await FluentActions.Invoking(() =>
+            Sender.Send(command)).Should().ThrowAsync<ValidationException>();
+    }
+
+    [Test]
+    public async Task CreateTodoItem_ShouldCreateTodoItem_WhenRequestIsValid()
+    {
+        // Arrange
+        var listId = await Sender.Send(new CreateTodoListCommand() { Title = "New List" });
+
+        var command = new CreateTodoItemCommand
+        {
+            ListId = listId.Value,
+            Title = "Tasks"
+        };
+
+        // Act
+        var itemId = await Sender.Send(command);
+
+        // Assert
+        var item = await FindAsync<TodoItem>(itemId.Value);
+
+        item.Should().NotBeNull();
+        item!.ListId.Should().Be(command.ListId);
+        item.Title.Should().Be(command.Title);
+        item.CreatedAtUtc.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromMilliseconds(10000));
+    }
+}

tests/Application.IntegrationTests/TodoItems/Commands/DeleteTodoItemTests.cs

@@ -0,0 +1,40 @@
+using System.ComponentModel;
+using Application.IntegrationTests.Infrastructure;
+using FastCleanArchitecture.Application.TodoItems.Commands.CreateTodoItem;
+using FastCleanArchitecture.Application.TodoItems.Commands.DeleteTodoItem;
+using FastCleanArchitecture.Application.TodoLists.Commands.Create;
+using FastCleanArchitecture.Domain.TodoItems;
+using FluentAssertions;
+using FluentResults;
+
+namespace Application.IntegrationTests.TodoItems.Commands;
+
+internal sealed class DeleteTodoItemTests : BaseIntegrationTest
+{
+    private Result<Guid> _listId;
+
+    [OneTimeSetUp]
+    public async Task SetUp() => _listId = await Sender.Send(new CreateTodoListCommand
+    {
+        Title = "New lists"
+    });
+
+    [TestCase(true)]
+    [TestCase(false)]
+    public async Task DeleteTodoItem_ShouldDeleteTodoItem_WhenValidParam(bool itemExists)
+    {
+        // Arrange
+        var itemId = itemExists ? await Sender.Send(new CreateTodoItemCommand
+        {
+            ListId = _listId.Value,
+            Title = "New item"
+        }) : Guid.NewGuid();
+
+        // Act
+        await Sender.Send(new DeleteTodoItemCommand(itemId.Value));
+
+        // Assert
+        var item = await FindAsync<TodoItem>(itemId.Value);
+        item.Should().BeNull();
+    }
+}

tests/Application.IntegrationTests/TodoItems/Commands/UpdateTodoItemDetailTests.cs

@@ -0,0 +1,64 @@
+using Application.IntegrationTests.Infrastructure;
+using FastCleanArchitecture.Application.TodoItems.Commands.CreateTodoItem;
+using FastCleanArchitecture.Application.TodoItems.Commands.UpdateTodoItemDetail;
+using FastCleanArchitecture.Application.TodoLists.Commands.Create;
+using FastCleanArchitecture.Domain.TodoItems;
+using FastCleanArchitecture.Domain.TodoItems.Enums;
+using FluentAssertions;
+
+namespace Application.IntegrationTests.TodoItems.Commands;
+
+internal sealed class UpdateTodoItemDetailTests : BaseIntegrationTest
+{
+    [Test]
+    public async Task UpdateTodoItemDetail_ShouldReturnFailure_WhenItemNotFound()
+    {
+        // Arrange
+        var command = new UpdateTodoItemDetailCommand
+        {
+            Id = Guid.NewGuid(),
+            Body = new UpdateTodoItemDetailCommand.BodyItemDetailRequest { }
+        };
+
+        // Act
+        var result = await Sender.Send(command);
+
+        // Assert
+        result.IsFailed.Should().BeTrue();
+    }
+
+    [Test]
+    public async Task UpdateTodoItemDetail_ShouldUpdateDetail_WhenValidParam()
+    {
+        // Arrange
+        var listId = await Sender.Send(new CreateTodoListCommand { Title = "New list" });
+        var itemId = await Sender.Send(new CreateTodoItemCommand
+        {
+            ListId = listId.Value,
+            Title = "New Item"
+        });
+
+        var command = new UpdateTodoItemDetailCommand
+        {
+            Id = itemId.Value,
+            Body = new UpdateTodoItemDetailCommand.BodyItemDetailRequest
+            {
+                ListId = listId.Value,
+                Note = "A nother note...",
+                Priority = PriorityLevel.High
+            }
+        };
+
+        // Act
+        await Sender.Send(command);
+
+        // Assert
+        var item = await FindAsync<TodoItem>(itemId.Value);
+
+        item.Should().NotBeNull();
+        item!.ListId.Should().Be(listId.Value);
+        item.Note.Should().Be(command.Body.Note);
+        item.Priority.Should().Be(command.Body.Priority);
+        item.ModifiedAtUtc.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromMilliseconds(10000));
+    }
+}

tests/Application.IntegrationTests/TodoItems/Commands/UpdateTodoItemTests.cs

@@ -0,0 +1,60 @@
+using Application.IntegrationTests.Infrastructure;
+using FastCleanArchitecture.Application.TodoItems.Commands.CreateTodoItem;
+using FastCleanArchitecture.Application.TodoItems.Commands.UpdateTodoItem;
+using FastCleanArchitecture.Application.TodoLists.Commands.Create;
+using FastCleanArchitecture.Domain.TodoItems;
+using FluentAssertions;
+
+namespace Application.IntegrationTests.TodoItems.Commands;
+
+internal sealed class UpdateTodoItemTests : BaseIntegrationTest
+{
+    [Test]
+    public async Task UpdateTodoItem_ShouldReturnFailure_WhenItemNotFound()
+    {
+        // Arrange
+        var command = new UpdateTodoItemCommand
+        {
+            Id = Guid.NewGuid(),
+            Body = new UpdateTodoItemCommand.BodyItemRequest() { Title = "New Title" }
+        };
+
+        // Act
+        var result = await Sender.Send(command);
+
+        // Assert
+        result.IsFailed.Should().BeTrue();
+    }
+
+    [Test]
+    public async Task UpdateTodoItem_ShouldUpdate_WhenValidParams()
+    {
+        // Arrange
+        var listId = await Sender.Send(new CreateTodoListCommand
+        {
+            Title = "New list",
+        });
+
+        var itemId = await Sender.Send(new CreateTodoItemCommand
+        {
+            ListId = listId.Value,
+            Title = "New item"
+        });
+
+        var command = new UpdateTodoItemCommand
+        {
+            Id = itemId.Value,
+            Body = new UpdateTodoItemCommand.BodyItemRequest { Title = "Updated item title" }
+        };
+
+        // Act
+        await Sender.Send(command);
+
+        // Assert
+        var item = await FindAsync<TodoItem>(itemId.Value);
+
+        item.Should().NotBeNull();
+        item!.Title.Should().Be(command.Body.Title);
+        item.ModifiedAtUtc.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromMilliseconds(10000));
+    }
+}

tests/Application.IntegrationTests/TodoLists/Commands/CreateTodoListTests.cs

@@ -0,0 +1,52 @@
+using Application.IntegrationTests.Infrastructure;
+using FastCleanArchitecture.Application.Common.Exceptions;
+using FastCleanArchitecture.Application.TodoLists.Commands.Create;
+using FastCleanArchitecture.Application.TodoLists.Queries.GetTodos;
+using FluentAssertions;
+
+namespace Application.IntegrationTests.TodoLists.Commands;
+
+internal class CreateTodoListTests : BaseIntegrationTest
+{
+    [Test]
+    public async Task CreateTodoList_ShouldThrowValidationException_WhenRequireAMinimunFields()
+    {
+        // Act
+        var act = () => Sender.Send(new CreateTodoListCommand());
+
+        // Assert
+        await act.Should().ThrowAsync<ValidationException>();
+    }
+
+    [Test]
+    public async Task CreatTodoList_ShouldThrowValidationException_WhenRequireUniqueTitle()
+    {
+        // Arrange
+        var command = new CreateTodoListCommand { Title = "Homeworks" };
+        await Sender.Send(command);
+
+        // Act and Assert
+        await FluentActions
+            .Invoking(() => Sender
+            .Send(command))
+            .Should()
+            .ThrowAsync<ValidationException>();
+    }
+
+    [Test]
+    public async Task CreateTodoList_ShouldCreateTodoList_WhenRequestIsValidAndSuccessful()
+    {
+        // Arrange
+        var command = new CreateTodoListCommand { Title = "Participate in a daily meeting." };
+
+        // Act
+        var result = await Sender.Send(command);
+
+        // Assert
+        var lists = await Sender.Send(new GetTodosQuery());
+        var list = lists.Value.Lists.FirstOrDefault(x => x.Id!.Equals(result.Value));
+
+        result.Value.Should().NotBeEmpty();
+        list!.Title.Should().Be(command.Title);
+    }
+}

tests/Application.IntegrationTests/TodoLists/Commands/DeleteTodoListTests.cs

@@ -0,0 +1,23 @@
+using Application.IntegrationTests.Infrastructure;
+using FastCleanArchitecture.Application.TodoLists.Commands.Create;
+using FastCleanArchitecture.Application.TodoLists.Commands.Delete;
+using FastCleanArchitecture.Domain.TodoLists;
+using FluentAssertions;
+
+namespace Application.IntegrationTests.TodoLists.Commands;
+
+internal class DeleteTodoListTests : BaseIntegrationTest
+{
+    [Test]
+    public async Task DeleteTodoList_ShouldDeleteTodoList_WhenRequestIsSuccessful()
+    {
+        var listId = await Sender.Send(new CreateTodoListCommand { Title = "New list" });
+
+        // Act
+        await Sender.Send(new DeleteTodoListCommand(listId.Value));
+
+        // Assert
+        var list = await FindAsync<TodoList>(listId.Value);
+        list.Should().BeNull();
+    }
+}