generator-codedesignplus 0.0.1-rc.2

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Commands/RemoveProduct/RemoveProductCommandHandlerTest.cs

@@ -0,0 +1,71 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.RemoveProduct;
+using CodeDesignPlus.Net.Microservice.Domain.ValueObjects;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.RemoveProduct;
+
+public class RemoveProductCommandHandlerTest
+{
+    private readonly IUserContext user;
+
+    public RemoveProductCommandHandlerTest()
+    {
+        var userMock = new Mock<IUserContext>();
+
+        userMock.Setup(x => x.IdUser).Returns(Guid.NewGuid());
+        userMock.Setup(x => x.Tenant).Returns(Guid.NewGuid());
+
+        this.user = userMock.Object;
+    }
+
+    [Fact]
+    public async Task Handle_OrderNotFound_ThrowApplicaionException()
+    {
+        // Arrange
+        var orderRepository = new Mock<IOrderRepository>();
+        var pubsub = new Mock<IPubSub>();
+        var handler = new RemoveProductCommandHandler(orderRepository.Object, user, pubsub.Object);
+        var request = new RemoveProductCommand(Guid.NewGuid(), Guid.NewGuid());
+
+        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync((OrderAggregate)null!);
+
+        // Act
+        var exception = await Assert.ThrowsAsync<CodeDesignPlusException>(() => handler.Handle(request, CancellationToken.None));
+
+        // Assert
+        Assert.Equal(Errors.OrderNotFound.GetMessage(), exception.Message);
+    }
+
+    [Fact]
+    public async Task Handle_Success()
+    {
+        // Arrange
+        var orderRepository = new Mock<IOrderRepository>();
+        var pubsub = new Mock<IPubSub>();
+        var handler = new RemoveProductCommandHandler(orderRepository.Object, user, pubsub.Object);
+        var request = new RemoveProductCommand(Guid.NewGuid(), Guid.NewGuid());
+        var clientValueObject = ClientValueObject.Create(Guid.NewGuid(), "Client", "1234567890", "CC");
+        var addressValueObject = AddressValueObject.Create("Colombia", "Bogota", "Bogota", "Calle 123", 123456);
+
+        var order = OrderAggregate.Create(Guid.NewGuid(), clientValueObject, addressValueObject, this.user.Tenant, this.user.IdUser);
+
+        order.Products.Add(new ProductEntity()
+        {
+            Id = request.ProductId,
+            Name = "Product",
+            Price = 100,
+            Quantity = 1
+        });
+
+        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
+
+        // Act
+        await handler.Handle(request, CancellationToken.None);
+
+        // Assert        
+        Assert.NotNull(order.UpdatedAt);
+        Assert.Equal(this.user.IdUser, order.UpdatedBy);
+        orderRepository.Verify(x => x.RemoveProductFromOrderAsync(It.IsAny<RemoveProductFromOrderParams>(), It.IsAny<CancellationToken>()), Times.Once);
+        pubsub.Verify(x => x.PublishAsync(It.IsAny<IReadOnlyList<IDomainEvent>>(), It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+}

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Commands/RemoveProduct/RemoveProductCommandTest.cs

@@ -0,0 +1,33 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.RemoveProduct;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.RemoveProduct;
+
+public class RemoveProductCommandTest
+{
+
+    private readonly Validator _validator;
+
+    public RemoveProductCommandTest()
+    {
+        _validator = new Validator();
+    }
+
+    [Fact]
+    public async Task Should_Have_Error_When_Id_Is_Empty()
+    {
+        var command = new RemoveProductCommand(Guid.Empty, Guid.NewGuid());
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.Id) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Fact]
+    public async Task Should_Have_Error_When_ProductId_Is_Empty()
+    {
+        var command = new RemoveProductCommand(Guid.NewGuid(), Guid.Empty);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.ProductId) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+}

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Commands/UpdateQuantityProduct/UpdateQuantityProductCommandHandlerTest.cs

@@ -0,0 +1,82 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.UpdateQuantityProduct;
+using CodeDesignPlus.Net.Microservice.Domain.ValueObjects;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.UpdateQuantityProduct;
+
+public class UpdateQuantityProductCommandHandlerTest
+{
+    private readonly IUserContext user;
+
+    public UpdateQuantityProductCommandHandlerTest()
+    {
+        var userMock = new Mock<IUserContext>();
+
+        userMock.Setup(x => x.IdUser).Returns(Guid.NewGuid());
+        userMock.Setup(x => x.Tenant).Returns(Guid.NewGuid());
+
+        this.user = userMock.Object;
+    }
+
+    [Fact]
+    public async Task Should_Throw_Exception_When_Order_Not_Found()
+    {
+        // Arrange
+        var orderRepository = new Mock<IOrderRepository>();
+        var pubsub = new Mock<IPubSub>();
+
+        var command = new UpdateQuantityProductCommand(Guid.NewGuid(), Guid.NewGuid(), 1);
+
+        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
+
+        var handler = new UpdateQuantityProductCommandHandler(orderRepository.Object, this.user, pubsub.Object);
+
+        // Act
+        var exception = await Assert.ThrowsAsync<CodeDesignPlusException>(() => handler.Handle(command, CancellationToken.None));
+
+        // Assert
+        orderRepository.Verify(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.UpdateQuantityProductAsync(It.IsAny<UpdateQuantityProductParams>(), It.IsAny<CancellationToken>()), Times.Never);
+        pubsub.Verify(x => x.PublishAsync(It.IsAny<IReadOnlyList<IDomainEvent>>(), It.IsAny<CancellationToken>()), Times.Never);
+
+        Assert.Equal(Errors.OrderNotFound.GetCode(), exception.Code);
+        Assert.Equal(Errors.OrderNotFound.GetMessage(), exception.Message);
+
+    }
+
+    [Fact]
+    public async Task Handler_Success()
+    {
+        // Arrange
+        var orderRepository = new Mock<IOrderRepository>();
+        var pubsub = new Mock<IPubSub>();
+        var client = ClientValueObject.Create(Guid.NewGuid(), "client", "1234567890", "CC");
+        var address = AddressValueObject.Create("Colombia", "Bogota", "Bogota", "Calle 123", 123456);
+
+        var order = OrderAggregate.Create(Guid.NewGuid(), client, address, this.user.Tenant, this.user.IdUser);
+
+        order.Products.Add(new ProductEntity()
+        {
+            Id = Guid.NewGuid(),
+            Name = "Product",
+            Price = 100,
+            Quantity = 1
+        });
+
+        var command = new UpdateQuantityProductCommand(order.Id, order.Products[0].Id, 2);
+
+        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
+
+        var handler = new UpdateQuantityProductCommandHandler(orderRepository.Object, this.user, pubsub.Object);
+
+        // Act
+        await handler.Handle(command, CancellationToken.None);
+
+        // Assert        
+        Assert.NotNull(order.UpdatedAt);
+        Assert.Equal(this.user.IdUser, order.UpdatedBy);
+        orderRepository.Verify(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.UpdateQuantityProductAsync(It.IsAny<UpdateQuantityProductParams>(), It.IsAny<CancellationToken>()), Times.Once);
+        pubsub.Verify(x => x.PublishAsync(It.IsAny<IReadOnlyList<IDomainEvent>>(), It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+}

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Commands/UpdateQuantityProduct/UpdateQuantityProductCommandTest.cs

@@ -0,0 +1,51 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.UpdateQuantityProduct;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.UpdateQuantityProduct;
+
+public class UpdateQuantityProductCommandTest
+{
+
+    private readonly Validator _validator;
+
+    public UpdateQuantityProductCommandTest()
+    {
+        _validator = new Validator();
+    }
+
+    [Fact]
+    public async Task Should_Have_Error_When_Id_Is_Empty()
+    {
+        var command = new UpdateQuantityProductCommand(Guid.Empty, Guid.NewGuid(), 1);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.Id) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Fact]
+    public async Task Should_Have_Error_When_ProductId_Is_Empty()
+    {
+        var command = new UpdateQuantityProductCommand(Guid.NewGuid(), Guid.Empty, 1);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.ProductId) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Fact]
+    public async Task Should_Have_Error_When_Quantity_Is_Less_Than_One()
+    {
+        var command = new UpdateQuantityProductCommand(Guid.NewGuid(), Guid.NewGuid(), 0);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.Quantity) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Fact]
+    public async Task Should_Not_Have_Error()
+    {
+        var command = new UpdateQuantityProductCommand(Guid.NewGuid(), Guid.NewGuid(), 1);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Empty(result.Errors);
+    }
+
+}

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Queries/FindOrderById/FindOrderByIdQueryHandlerTest.cs

@@ -0,0 +1,70 @@
+using CodeDesignPlus.Net.Cache.Abstractions;
+using CodeDesignPlus.Net.Microservice.Application.Order.Queries.FindOrderById;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Queries.FindOrderById;
+
+public class FindOrderByIdQueryHandlerTest
+{
+    [Fact]
+    public async Task Handle_ValidId_ReturnsOrderDto()
+    {
+        // Arrange
+        var orderRepository = new Mock<IOrderRepository>();
+        var mapper = new Mock<IMapper>();
+        var query = new FindOrderByIdQuery(Guid.NewGuid());
+        var cancellationToken = new CancellationToken();
+        var dtoExpected = new OrderDto();        
+        var cacheManagerMock = new Mock<ICacheManager>();
+
+        cacheManagerMock.Setup(x => x.ExistsAsync(It.IsAny<string>())).ReturnsAsync(false);
+        cacheManagerMock.Setup(x => x.SetAsync(It.IsAny<string>(), It.IsAny<OrderDto>(), It.IsAny<TimeSpan?>()));
+
+        mapper.Setup(x => x.Map<OrderDto>(It.IsAny<object>())).Returns(dtoExpected);
+
+        var handler = new FindOrderByIdQueryHandler(orderRepository.Object, mapper.Object, cacheManagerMock.Object);
+
+        // Act
+        var result = await handler.Handle(query, cancellationToken);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.IsType<OrderDto>(result);
+        Assert.Equal(dtoExpected, result);
+        orderRepository.Verify(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()), Times.Once);
+        mapper.Verify(x => x.Map<OrderDto>(It.IsAny<object>()), Times.Once);
+        cacheManagerMock.Verify(x => x.SetAsync(It.IsAny<string>(), It.IsAny<OrderDto>(), It.IsAny<TimeSpan?>()), Times.Once);
+        cacheManagerMock.Verify(x => x.ExistsAsync(It.IsAny<string>()), Times.Once);
+    }
+
+    
+    [Fact]
+    public async Task Handle_Cache_ReturnsOrderDto()
+    {
+        // Arrange
+        var orderRepository = new Mock<IOrderRepository>();
+        var mapper = new Mock<IMapper>();
+        var query = new FindOrderByIdQuery(Guid.NewGuid());
+        var cancellationToken = new CancellationToken();
+        var dtoExpected = new OrderDto();
+        var cacheManagerMock = new Mock<ICacheManager>();
+
+        cacheManagerMock.Setup(x => x.ExistsAsync(It.IsAny<string>())).ReturnsAsync(true);
+        cacheManagerMock.Setup(x => x.GetAsync<OrderDto>(It.IsAny<string>())).ReturnsAsync(dtoExpected);
+
+        mapper.Setup(x => x.Map<OrderDto>(It.IsAny<object>())).Returns(dtoExpected);
+
+        var handler = new FindOrderByIdQueryHandler(orderRepository.Object, mapper.Object, cacheManagerMock.Object);
+
+        // Act
+        var result = await handler.Handle(query, cancellationToken);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.IsType<OrderDto>(result);
+        Assert.Equal(dtoExpected, result);
+        orderRepository.Verify(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()), Times.Never);
+        mapper.Verify(x => x.Map<OrderDto>(It.IsAny<object>()), Times.Never);
+        cacheManagerMock.Verify(x => x.GetAsync<OrderDto>(It.IsAny<string>()), Times.Once);
+        cacheManagerMock.Verify(x => x.ExistsAsync(It.IsAny<string>()), Times.Once);
+    }
+}

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Queries/GetAllOrders/GetAllOrdersQueryHandlerTest.cs

@@ -0,0 +1,80 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Queries.GetAllOrders;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Queries.GetAllOrders;
+
+public class GetAllOrdersQueryHandlerTest
+{
+
+    [Fact]
+    public async Task Handle_Success()
+    {
+        // Arrange
+        var criteria = new C.Criteria();
+        var query = new GetAllOrdersQuery(criteria);
+        var orders = new List<OrderDto>
+        {
+            new() {
+                Id = Guid.NewGuid(),
+                Client = new ClientDto(){
+                    Name = "Client 1",
+                    Document = "123456789",
+                    TypeDocument = "CC",
+                    Id = Guid.NewGuid()
+                },
+                CompletedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                CreatedBy = Guid.NewGuid(),
+                CreatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                IsActive = true,
+                Products = [
+                    new(){
+                        Id = Guid.NewGuid(),
+                        Name = "Product 1",
+                        Price = 100,
+                        Quantity = 1
+                    }
+                ],
+
+            },
+            new() {
+                Id = Guid.NewGuid(),
+                Client = new ClientDto(){
+                    Name = "Client 2",
+                    Document = "987654321",
+                    TypeDocument = "CC",
+                    Id = Guid.NewGuid()
+                },
+                CompletedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                CreatedBy = Guid.NewGuid(),
+                CreatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                IsActive = true,
+                Products = [
+                    new(){
+                        Id = Guid.NewGuid(),
+                        Name = "Product 2",
+                        Price = 200,
+                        Quantity = 2
+                    }
+                ],
+
+            }
+        };
+
+        var orderRepositoryMock = new Mock<IOrderRepository>();
+        var mapperMock = new Mock<IMapper>();
+        var queryHandler = new GetAllOrdersQueryHandler(orderRepositoryMock.Object, mapperMock.Object);
+
+        mapperMock.Setup(x => x.Map<List<OrderDto>>(It.IsAny<List<OrderAggregate>>())).Returns(orders);
+
+        // Act
+        var result = await queryHandler.Handle(query, CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.NotEmpty(result);
+        Assert.Equal(orders.Count, result.Count);
+
+        orderRepositoryMock.Verify(x => x.MatchingAsync<OrderAggregate>(criteria, It.IsAny<CancellationToken>()), Times.Once);
+        mapperMock.Verify(x => x.Map<List<OrderDto>>(It.IsAny<List<OrderAggregate>>()), Times.Once);
+    }
+
+}

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Setup/MapsterConfigTest.cs

@@ -0,0 +1,20 @@
+using CodeDesignPlus.Net.Microservice.Application.Setup;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Setup;
+
+public class MapsterConfigTest
+{
+    [Fact]
+    public void Configure_ShouldMapProperties_Success()
+    {
+        // Arrange
+        var config = TypeAdapterConfig.GlobalSettings;
+        config.Scan(typeof(MapsterConfigOrder).Assembly);
+
+        // Act
+        var mapper = new Mapper(config);
+
+        // Assert
+        Assert.NotNull(mapper);
+    }
+}

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Usings.cs

@@ -0,0 +1,18 @@
+global using CodeDesignPlus.Net.Core.Abstractions;
+global using CodeDesignPlus.Net.Exceptions.Extensions;
+global using CodeDesignPlus.Net.PubSub.Abstractions;
+global using Moq;
+global using System;
+global using CodeDesignPlus.Net.Security.Abstractions;
+global using CodeDesignPlus.Net.Exceptions;
+global using Mapster;
+global using MapsterMapper;
+global using C = CodeDesignPlus.Net.Core.Abstractions.Models.Criteria;
+global using CodeDesignPlus.Net.Serializers;
+
+global using CodeDesignPlus.Net.Microservice.Application.Order.DataTransferObjects;
+global using CodeDesignPlus.Net.Microservice.Domain.Enums;
+global using CodeDesignPlus.Net.Microservice.Domain.Entities;
+global using CodeDesignPlus.Net.Microservice.Domain;
+global using CodeDesignPlus.Net.Microservice.Domain.Repositories;
+global using CodeDesignPlus.Net.Microservice.Domain.DataTransferObjects;

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.AsyncWorker.Test/CodeDesignPlus.Net.Microservice.AsyncWorker.Test.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <IsPackable>false</IsPackable>
+    <SonarQubeExclude>true</SonarQubeExclude>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="coverlet.msbuild" Version="6.0.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="6.0.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="CodeDesignPlus.Net.xUnit.Microservice" Version="0.5.0-beta.60" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\src\entrypoints\CodeDesignPlus.Net.Microservice.AsyncWorker\CodeDesignPlus.Net.Microservice.AsyncWorker.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Consumers\" />
+  </ItemGroup>
+</Project>

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.AsyncWorker.Test/Usings.cs

@@ -0,0 +1,9 @@
+global using CodeDesignPlus.Net.xUnit.Microservice.Utils.Logger;
+global using Microsoft.Extensions.Logging;
+global using Moq;
+global using Newtonsoft.Json;
+global using System;
+global using CodeDesignPlus.Net.Serializers;
+
+global using CodeDesignPlus.Net.Microservice.Domain.DomainEvents;
+global using CodeDesignPlus.Net.Microservice.Domain.Entities;

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Default.Test/CodeDesignPlus.Net.Microservice.Default.Test.csproj

@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="CodeDesignPlus.Net.Serializers" Version="0.5.0-beta.60" />
+    <PackageReference Include="coverlet.msbuild" Version="6.0.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="6.0.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="CodeDesignPlus.Net.xUnit.Microservice" Version="0.5.0-beta.60" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\src\domain\CodeDesignPlus.Net.Microservice.Infrastructure\CodeDesignPlus.Net.Microservice.Infrastructure.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Validations\" />
+  </ItemGroup>
+</Project>

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Default.Test/Usings.cs

@@ -0,0 +1,6 @@
+global using CodeDesignPlus.Net.xUnit.Microservice.Attributes;
+global using System.Reflection;
+global using CodeDesignPlus.Net.Core.Abstractions;
+global using CodeDesignPlus.Net.xUnit.Microservice.Utils.Reflection;
+global using Xunit;
+// global using CodeDesignPlus.Net.Serializers;

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Default.Test/Validations/AggregateTest.cs

@@ -0,0 +1,37 @@
+namespace CodeDesignPlus.Net.Microservice.Default.Test.Validations;
+
+/// <summary>
+/// A class for validating aggregates.
+/// </summary>
+public class AggregateTest
+{
+    /// <summary>
+    /// Validates that aggregates can be created using the constructor and their properties can be set and retrieved correctly.
+    /// </summary>
+    [Theory]
+    [Aggregate<Domain.Errors>(false)]
+    public void Aggregate_Constructor_ShouldSetAndRetrievePropertiesCorrectly(Type aggregate, object instance, Dictionary<ParameterInfo, object> values)
+    {
+        // Assert
+        Assert.NotNull(instance);
+
+        var value = aggregate.GetProperty(nameof(AggregateRoot.Id))!.GetValue(instance, null);
+        var valueExpected = values.First(x => x.Key.Name!.Equals(nameof(AggregateRoot.Id), StringComparison.OrdinalIgnoreCase)).Value;
+        Assert.Equal(valueExpected, value);
+    }
+
+    /// <summary>
+    /// Validates that aggregates can be created using the named constructor with custom values.
+    /// </summary>
+    [Theory]
+    [Aggregate<Domain.Errors>(true)]
+    public void Aggregate_CreateMethod_ShouldCreateInstanceWithCustomValues(Type aggregate, object instance, Dictionary<ParameterInfo, object> values)
+    {
+        // Assert
+        Assert.NotNull(instance);
+
+        var value = aggregate.GetProperty(nameof(AggregateRoot.Id))!.GetValue(instance, null);
+        var valueExpected = values.First(x => x.Key.Name!.Equals(nameof(AggregateRoot.Id), StringComparison.OrdinalIgnoreCase)).Value;
+        Assert.Equal(valueExpected, value);
+    }
+}

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Default.Test/Validations/CommandsTests.cs

@@ -0,0 +1,29 @@
+namespace CodeDesignPlus.Net.Microservice.Default.Test.Validations;
+
+/// <summary>
+/// A class for validating commands.
+/// </summary>
+public class CommandsTests
+{
+    /// <summary>
+    /// Validates that commands can be created and their properties can be set and retrieved correctly.
+    /// </summary>
+    [Theory]
+    [Command<Application.Errors>]
+    public void Commands_GetAndSet_Success(Type command, object instance, Dictionary<ParameterInfo, object> values)
+    {
+        // Assert
+        Assert.NotNull(instance);
+
+        var properties = command.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+
+        foreach (var property in properties)
+        {
+            var value = property.GetValue(instance);
+            var valueExpected = values.FirstOrDefault(x => x.Key.Name == property.Name).Value;
+
+            Assert.NotNull(value);
+            Assert.Equal(valueExpected, value);
+        }
+    }
+}

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Default.Test/Validations/DataTransferObjectTest.cs

@@ -0,0 +1,47 @@
+namespace CodeDesignPlus.Net.Microservice.Default.Test.Validations;
+
+/// <summary>
+/// A class for validating data transfer objects (DTOs).
+/// </summary>
+public class DataTransferObjectTests
+{
+    /// <summary>
+    /// Validates that DTOs can be created and their properties can be set and retrieved correctly.
+    /// </summary>
+    [Theory]
+    [DataTransferObject<Application.Errors>]
+    public void Dtos_GetAndSet_Application(Type dto, object instance)
+    {
+        // Assert
+        Assert.NotNull(instance);
+
+        var properties = dto.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+
+        foreach (var property in properties)
+        {
+            var value = property.GetValue(instance);
+            Assert.NotNull(value);
+            Assert.NotEqual(value, property.PropertyType.GetDefaultValue());
+        }
+    }
+
+    /// <summary>
+    /// Validates that DTOs can be created and their properties can be set and retrieved correctly.
+    /// </summary>
+    [Theory]
+    [DataTransferObject<Domain.Errors>]
+    public void Dtos_GetAndSet_Domain(Type dto, object instance)
+    {
+        // Assert
+        Assert.NotNull(instance);
+
+        var properties = dto.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+
+        foreach (var property in properties)
+        {
+            var value = property.GetValue(instance);
+            Assert.NotNull(value);
+            Assert.NotEqual(value, property.PropertyType.GetDefaultValue());
+        }
+    }
+}