generator-codedesignplus 0.0.1-rc.2

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Infrastructure.Test/Repositories/OrderRepositoryTest.cs

@@ -0,0 +1,259 @@
+using CodeDesignPlus.Net.Microservice.Domain.ValueObjects;
+
+namespace CodeDesignPlus.Net.Microservice.Infrastructure.Test.Repositories;
+
+public class OrderRepositoryTest
+{
+    private readonly ServiceProvider serviceProvider;
+    private readonly Mock<IMongoClient> mongoClientMock;
+    private readonly Mock<IMongoDatabase> mongoDatabaseMock;
+    private readonly IOptions<MongoOptions> mongoOptions;
+    private readonly Mock<ILogger<RepositoryBase>> loggerMock;
+    private readonly Mock<IMongoCollection<OrderAggregate>> collectionMock;
+    private readonly OrderRepository orderRepository;
+
+    public OrderRepositoryTest()
+    {
+        mongoClientMock = new Mock<IMongoClient>();
+        mongoDatabaseMock = new Mock<IMongoDatabase>();
+        this.mongoOptions = Options.Create(new MongoOptions());
+        loggerMock = new Mock<ILogger<RepositoryBase>>();
+        collectionMock = new Mock<IMongoCollection<OrderAggregate>>();
+
+        mongoDatabaseMock.Setup(x => x.GetCollection<OrderAggregate>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
+            .Returns(collectionMock.Object);
+
+        mongoClientMock.Setup(x => x.GetDatabase(It.IsAny<string>(), It.IsAny<MongoDatabaseSettings>()))
+            .Returns(mongoDatabaseMock.Object);
+
+        var serviceCollection = new ServiceCollection();
+
+        serviceCollection.AddSingleton(mongoClientMock.Object);
+        serviceCollection.AddSingleton(this.mongoOptions);
+        serviceCollection.AddSingleton(loggerMock.Object);
+
+        serviceProvider = serviceCollection.BuildServiceProvider();
+
+        var mongoOptions2 = serviceProvider.GetService<IOptions<MongoOptions>>();
+        var logger = serviceProvider.GetService<ILogger<RepositoryBase>>();
+
+        orderRepository = new OrderRepository(
+            serviceProvider,
+            mongoOptions2!,
+            logger!
+        );
+    }
+
+    [Fact]
+    public async Task AddProductToOrderAsync_Should_Add_Product_To_Order()
+    {
+        // Arrange
+        var idOrder = Guid.NewGuid();
+        var idProduct = Guid.NewGuid();
+        var name = "Product Name";
+        var description = "Product Description";
+        var price = 100;
+        var quantity = 1;
+        var cancellationToken = CancellationToken.None;
+
+        collectionMock
+            .Setup(x => x.UpdateOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<UpdateDefinition<OrderAggregate>>(), It.IsAny<UpdateOptions>(), cancellationToken))
+            .ReturnsAsync(It.IsAny<UpdateResult>());
+
+        // Act
+        await orderRepository.AddProductToOrderAsync(new AddProductToOrderParams()
+        {
+            Id = idOrder,
+            IdProduct = idProduct,
+            Name = name,
+            Description = description,
+            Price = price,
+            Quantity = quantity,
+            UpdatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+            UpdateBy = Guid.NewGuid()
+        }, cancellationToken);
+
+        // Assert
+        collectionMock.Verify(x => x.UpdateOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<UpdateDefinition<OrderAggregate>>(), It.IsAny<UpdateOptions>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task CancelOrderAsync_Should_Cancel_Order()
+    {
+        // Arrange
+        var idOrder = Guid.NewGuid();
+        var reason = "Reason for cancellation";
+        var cancellationToken = CancellationToken.None;
+        var cancelledAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        collectionMock
+            .Setup(x => x.UpdateOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<UpdateDefinition<OrderAggregate>>(), It.IsAny<UpdateOptions>(), cancellationToken))
+            .ReturnsAsync(It.IsAny<UpdateResult>());
+
+        // Act
+        await orderRepository.CancelOrderAsync(new CancelOrderParams()
+        {
+            Id = idOrder,
+            OrderStatus = OrderStatus.Cancelled,
+            Reason = reason,
+            CancelledAt = cancelledAt,
+            UpdatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+            UpdateBy = Guid.NewGuid()
+        }, cancellationToken);
+
+        // Assert
+        collectionMock.Verify(x => x.UpdateOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<UpdateDefinition<OrderAggregate>>(), It.IsAny<UpdateOptions>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task CompleteOrderAsync_Should_Complete_Order()
+    {
+        // Arrange
+        var idOrder = Guid.NewGuid();
+        var cancellationToken = CancellationToken.None;
+        var completedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        collectionMock
+            .Setup(x => x.UpdateOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<UpdateDefinition<OrderAggregate>>(), It.IsAny<UpdateOptions>(), cancellationToken))
+            .ReturnsAsync(It.IsAny<UpdateResult>());
+
+        // Act
+        await orderRepository.CompleteOrderAsync(new CompleteOrderParams()
+        {
+            Id = idOrder,
+            CompletedAt = completedAt,
+            OrderStatus = OrderStatus.Completed,
+            UpdatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+            UpdateBy = Guid.NewGuid()
+        }, cancellationToken);
+
+        // Assert
+        collectionMock.Verify(x => x.UpdateOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<UpdateDefinition<OrderAggregate>>(), It.IsAny<UpdateOptions>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task CreateOrderAsync_Should_Create_Order()
+    {
+        // Arrange
+        var client = ClientValueObject.Create(Guid.NewGuid(), "CodeDesignPlus", "1234567890", "CC");
+        var address = AddressValueObject.Create("Colombia", "Bogota", "Bogota", "Calle 123", 123456);
+        var order = OrderAggregate.Create(Guid.NewGuid(), client, address, Guid.NewGuid(), Guid.NewGuid());
+        var cancellationToken = CancellationToken.None;
+
+        collectionMock
+            .Setup(x => x.InsertOneAsync(It.IsAny<OrderAggregate>(), It.IsAny<InsertOneOptions>(), cancellationToken));
+
+        // Act
+        await orderRepository.CreateOrderAsync(order, cancellationToken);
+
+        // Assert
+        collectionMock.Verify(x => x.InsertOneAsync(It.IsAny<OrderAggregate>(), It.IsAny<InsertOneOptions>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task FindAsync_Should_Find_Order()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var cancellationToken = CancellationToken.None;
+
+        collectionMock
+            .Setup(x => x.FindAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<FindOptions<OrderAggregate, OrderAggregate>>(), cancellationToken))
+            .ReturnsAsync(new Mock<IAsyncCursor<OrderAggregate>>().Object);
+
+        // Act
+        await orderRepository.FindAsync(id, cancellationToken);
+
+        // Assert
+        collectionMock.Verify(x => x.FindAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<FindOptions<OrderAggregate, OrderAggregate>>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task GetAllOrdersAsync_Should_Get_All_Orders()
+    {
+        // Arrange
+        var cancellationToken = CancellationToken.None;
+
+        collectionMock
+            .Setup(x => x.FindAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<FindOptions<OrderAggregate, OrderAggregate>>(), cancellationToken))
+            .ReturnsAsync(new Mock<IAsyncCursor<OrderAggregate>>().Object);
+
+        // Act
+        await orderRepository.GetAllOrdersAsync(cancellationToken);
+
+        // Assert
+        collectionMock.Verify(x => x.FindAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<FindOptions<OrderAggregate, OrderAggregate>>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task RemoveProductFromOrderAsync_Should_Remove_Product_From_Order()
+    {
+        // Arrange
+        var idOrder = Guid.NewGuid();
+        var idProduct = Guid.NewGuid();
+        var cancellationToken = CancellationToken.None;
+
+        collectionMock
+            .Setup(x => x.UpdateOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<UpdateDefinition<OrderAggregate>>(), It.IsAny<UpdateOptions>(), cancellationToken))
+            .ReturnsAsync(It.IsAny<UpdateResult>());
+
+        // Act
+        await orderRepository.RemoveProductFromOrderAsync( new RemoveProductFromOrderParams()
+        {
+            Id = idOrder,
+            IdProduct = idProduct,
+            UpdatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+            UpdateBy = Guid.NewGuid()
+        }, cancellationToken);
+
+        // Assert
+        collectionMock.Verify(x => x.UpdateOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<UpdateDefinition<OrderAggregate>>(), It.IsAny<UpdateOptions>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task UpdateOrderAsync_Should_Update_Order()
+    {
+        // Arrange
+        var client = ClientValueObject.Create(Guid.NewGuid(), "CodeDesignPlus", "1234567890", "CC");
+        var address = AddressValueObject.Create("Colombia", "Bogota", "Bogota", "Calle 123", 123456);
+        var order = OrderAggregate.Create(Guid.NewGuid(), client, address, Guid.NewGuid(), Guid.NewGuid());
+        var cancellationToken = CancellationToken.None;
+
+        collectionMock
+            .Setup(x => x.ReplaceOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<OrderAggregate>(), It.IsAny<ReplaceOptions>(), cancellationToken))
+            .ReturnsAsync(It.IsAny<ReplaceOneResult>());
+
+        // Act
+        await orderRepository.UpdateOrderAsync(order, cancellationToken);
+
+        // Assert
+        collectionMock.Verify(x => x.ReplaceOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<OrderAggregate>(), It.IsAny<ReplaceOptions>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task UpdateQuantityProductAsync_Should_Update_Quantity_Product()
+    {
+        // Arrange
+        var idOrder = Guid.NewGuid();
+        var productId = Guid.NewGuid();
+        var newQuantity = 10;
+        var cancellationToken = CancellationToken.None;
+
+        collectionMock
+            .Setup(x => x.UpdateOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<UpdateDefinition<OrderAggregate>>(), It.IsAny<UpdateOptions>(), cancellationToken))
+            .ReturnsAsync(It.IsAny<UpdateResult>());
+
+        // Act
+        await orderRepository.UpdateQuantityProductAsync(new UpdateQuantityProductParams()
+        {
+            Id = idOrder,
+            ProductId = productId,
+            NewQuantity = newQuantity,
+            UpdatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+            UpdateBy = Guid.NewGuid()
+        }, cancellationToken);
+
+        // Assert
+        collectionMock.Verify(x => x.UpdateOneAsync(It.IsAny<FilterDefinition<OrderAggregate>>(), It.IsAny<UpdateDefinition<OrderAggregate>>(), It.IsAny<UpdateOptions>(), cancellationToken), Times.Once);
+    }
+}

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

@@ -0,0 +1,14 @@
+global using CodeDesignPlus.Net.Mongo.Abstractions.Options;
+global using CodeDesignPlus.Net.Mongo.Repository;
+global using Microsoft.Extensions.DependencyInjection;
+global using Microsoft.Extensions.Logging;
+global using Microsoft.Extensions.Options;
+global using MongoDB.Driver;
+global using Moq;
+global using Microsoft.Extensions.Configuration;
+global using CodeDesignPlus.Net.Serializers;
+
+global using CodeDesignPlus.Net.Microservice.Infrastructure.Repositories;
+global using CodeDesignPlus.Net.Microservice.Domain;
+global using CodeDesignPlus.Net.Microservice.Domain.Enums;
+global using CodeDesignPlus.Net.Microservice.Domain.DataTransferObjects;

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

@@ -0,0 +1,40 @@
+<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>
+  <Target Name="DisableAnalyzers" BeforeTargets="CoreCompile">
+    <ItemGroup>
+      <Analyzer Remove="@(Analyzer)" Condition="'%(Filename)' == 'CodeDesignPlus.Net.Generator'" />
+    </ItemGroup>
+  </Target>
+  <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.Rest\CodeDesignPlus.Net.Microservice.Rest.csproj" />
+  </ItemGroup>
+</Project>

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Rest.Test/Controllers/OrderControllerTest.cs

@@ -0,0 +1,189 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.AddProductToOrder;
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.CancelOrder;
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.CompleteOrder;
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.CreateOrder;
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.RemoveProduct;
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.UpdateQuantityProduct;
+using CodeDesignPlus.Net.Microservice.Application.Order.DataTransferObjects;
+using CodeDesignPlus.Net.Microservice.Application.Order.Queries.FindOrderById;
+using CodeDesignPlus.Net.Microservice.Application.Order.Queries.GetAllOrders;
+
+namespace CodeDesignPlus.Net.Microservice.Rest.Test.Controllers;
+
+public class OrderControllerTest
+{
+    private readonly Mock<IMediator> mediator;
+    private readonly Mock<IMapper> mapper;
+
+    public OrderControllerTest()
+    {
+        this.mediator = new Mock<IMediator>();
+        this.mapper = new Mock<IMapper>();
+    }
+
+    [Fact]
+    public async Task GetOrdersAsync_WhenCalled_ReturnsOk()
+    {
+        // Arrange
+        var controller = new OrdersController(this.mediator.Object, this.mapper.Object);
+        var criteria = new C.Criteria();
+        var cancellationToken = new CancellationToken();
+
+        this.mediator
+            .Setup(x => x.Send(It.IsAny<GetAllOrdersQuery>(), cancellationToken))
+            .ReturnsAsync([]);
+
+        // Act
+        var result = await controller.GetOrders(criteria, cancellationToken);
+
+        // Assert
+        Assert.IsType<OkObjectResult>(result);
+        this.mediator.Verify(x => x.Send(It.IsAny<GetAllOrdersQuery>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task GetOrderByIdAsync_WhenCalled_ReturnsOk()
+    {
+        // Arrange
+        var controller = new OrdersController(this.mediator.Object, this.mapper.Object);
+        var id = Guid.NewGuid();
+        var cancellationToken = new CancellationToken();
+
+        this.mediator
+            .Setup(x => x.Send(It.IsAny<FindOrderByIdQuery>(), cancellationToken))
+            .ReturnsAsync(new OrderDto());
+
+        // Act
+        var result = await controller.GetOrderById(id, cancellationToken);
+
+        // Assert
+        Assert.IsType<OkObjectResult>(result);
+        this.mediator.Verify(x => x.Send(It.IsAny<FindOrderByIdQuery>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task CreateOrderAsync_WhenCalled_ReturnsNoContent()
+    {
+        // Arrange
+        var controller = new OrdersController(this.mediator.Object, this.mapper.Object);
+        var data = new CodeDesignPlus.Microservice.Api.Dtos.CreateOrderDto();
+        var cancellationToken = new CancellationToken();
+
+        this.mediator
+            .Setup(x => x.Send(It.IsAny<CreateOrderCommand>(), cancellationToken))
+            .Returns(Task.CompletedTask);
+
+        // Act
+        var result = await controller.CreateOrder(data, cancellationToken);
+
+        // Assert
+        Assert.IsType<NoContentResult>(result);
+        this.mediator.Verify(x => x.Send(It.IsAny<CreateOrderCommand>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task CancelOrderAsync_WhenCalled_ReturnsNoContent()
+    {
+        // Arrange
+        var controller = new OrdersController(this.mediator.Object, this.mapper.Object);
+        var id = Guid.NewGuid();
+        var data = new CodeDesignPlus.Microservice.Api.Dtos.CancelOrderDto();
+        var cancellationToken = new CancellationToken();
+
+        this.mediator
+            .Setup(x => x.Send(It.IsAny<CancelOrderCommand>(), cancellationToken))
+            .Returns(Task.CompletedTask);
+
+        // Act
+        var result = await controller.CancelOrder(id, data, cancellationToken);
+
+        // Assert
+        Assert.IsType<NoContentResult>(result);
+        this.mediator.Verify(x => x.Send(It.IsAny<CancelOrderCommand>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task CompleteOrderAsync_WhenCalled_ReturnsNoContent()
+    {
+        // Arrange
+        var controller = new OrdersController(this.mediator.Object, this.mapper.Object);
+        var id = Guid.NewGuid();
+        var cancellationToken = new CancellationToken();
+
+        this.mediator
+            .Setup(x => x.Send(It.IsAny<CompleteOrderCommand>(), cancellationToken))
+            .Returns(Task.CompletedTask);
+
+        // Act
+        var result = await controller.CompleteOrder(id, cancellationToken);
+
+        // Assert
+        Assert.IsType<NoContentResult>(result);
+        this.mediator.Verify(x => x.Send(It.IsAny<CompleteOrderCommand>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task AddProductToOrderAsync_WhenCalled_ReturnsNoContent()
+    {
+        // Arrange
+        var controller = new OrdersController(this.mediator.Object, this.mapper.Object);
+        var id = Guid.NewGuid();
+        var data = new CodeDesignPlus.Microservice.Api.Dtos.AddProductToOrderDto();
+        var cancellationToken = new CancellationToken();
+
+        this.mediator
+            .Setup(x => x.Send(It.IsAny<AddProductToOrderCommand>(), cancellationToken))
+            .Returns(Task.CompletedTask);
+
+        // Act
+        var result = await controller.AddProductToOrder(id, data, cancellationToken);
+
+        // Assert
+        Assert.IsType<NoContentResult>(result);
+        this.mediator.Verify(x => x.Send(It.IsAny<AddProductToOrderCommand>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task UpdateQuantityProductAsync_WhenCalled_ReturnsNoContent()
+    {
+        // Arrange
+        var controller = new OrdersController(this.mediator.Object, this.mapper.Object);
+        var id = Guid.NewGuid();
+        var productId = Guid.NewGuid();
+        var data = new CodeDesignPlus.Microservice.Api.Dtos.UpdateQuantityProductDto();
+        var cancellationToken = new CancellationToken();
+
+        this.mediator
+            .Setup(x => x.Send(It.IsAny<UpdateQuantityProductCommand>(), cancellationToken))
+            .Returns(Task.CompletedTask);
+
+        // Act
+        var result = await controller.UpdateQuantityProduct(id, productId, data, cancellationToken);
+
+        // Assert
+        Assert.IsType<NoContentResult>(result);
+        this.mediator.Verify(x => x.Send(It.IsAny<UpdateQuantityProductCommand>(), cancellationToken), Times.Once);
+    }
+
+    [Fact]
+    public async Task RemoveProductFromOrderAsync_WhenCalled_ReturnsNoContent()
+    {
+        // Arrange
+        var controller = new OrdersController(this.mediator.Object, this.mapper.Object);
+        var id = Guid.NewGuid();
+        var productId = Guid.NewGuid();
+        var cancellationToken = new CancellationToken();
+
+        this.mediator
+            .Setup(x => x.Send(It.IsAny<RemoveProductCommand>(), cancellationToken))
+            .Returns(Task.CompletedTask);
+
+        // Act
+        var result = await controller.RemoveProduct(id, productId, cancellationToken);
+
+        // Assert
+        Assert.IsType<NoContentResult>(result);
+        this.mediator.Verify(x => x.Send(It.IsAny<RemoveProductCommand>(), cancellationToken), Times.Once);
+    }
+
+}

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Rest.Test/Core/Mapster/MapsterConfigTest.cs

@@ -0,0 +1,19 @@
+namespace CodeDesignPlus.Net.Microservice.Rest.Test.Core.Mapster;
+
+public class MapsterConfigTest
+{
+    [Fact]
+    public void Configure_ShouldMapProperties_Success()
+    {
+        // Arrange
+        MapsterConfig.Configure();
+        var config = TypeAdapterConfig.GlobalSettings;
+
+        // Act
+        var mapper = new Mapper(config);
+
+        // Assert
+        Assert.NotNull(mapper);
+        Assert.NotEmpty(config.RuleMap);
+    }
+}

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

@@ -0,0 +1,14 @@
+global using CodeDesignPlus.Net.Microservice.Rest.Core.Mapster;
+global using Mapster;
+global using MapsterMapper;
+global using MediatR;
+global using Moq;
+global using System;
+global using System.Threading;
+global using System.Threading.Tasks;
+global using Xunit;
+global using C = CodeDesignPlus.Net.Core.Abstractions.Models.Criteria;
+global using Microsoft.AspNetCore.Mvc;
+global using CodeDesignPlus.Net.Serializers;
+
+global using CodeDesignPlus.Net.Microservice.Rest.Controllers;

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

@@ -0,0 +1,39 @@
+<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="Grpc.Core.Testing" Version="2.46.6" />
+    <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>
+    <Folder Include="Core/Mapster/" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\src\entrypoints\CodeDesignPlus.Net.Microservice.gRpc\CodeDesignPlus.Net.Microservice.gRpc.csproj" />
+  </ItemGroup>
+</Project>

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.gRpc.Test/Core/Mapster/MapsterConfigTest.cs

@@ -0,0 +1,19 @@
+namespace CodeDesignPlus.Net.Microservice.gRpc.Test.Core.Mapster;
+
+public class MapsterConfigTest
+{
+    [Fact]
+    public void Configure_ShouldMapProperties_Success()
+    {
+        // Arrange
+        CodeDesignPlus.Net.Microservice.gRpc.Core.Mapster.MapsterConfig.Configure();
+        var config = TypeAdapterConfig.GlobalSettings;
+
+        // Act
+        var mapper = new Mapper(config);
+
+        // Assert
+        Assert.NotNull(mapper);
+        Assert.NotEmpty(config.RuleMap);
+    }
+}

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.gRpc.Test/Services/OrderServiceTest.cs

@@ -0,0 +1,72 @@
+namespace CodeDesignPlus.Net.Microservice.gRpc.Test.Services;
+
+public class OrderServiceTest
+{
+    private readonly Mock<IMediator> _mediatorMock;
+    private readonly Mock<IMapper> _mapperMock;
+    private readonly OrdersService _ordersService;
+
+    public OrderServiceTest()
+    {
+        _mediatorMock = new Mock<IMediator>();
+        _mapperMock = new Mock<IMapper>();
+        _ordersService = new OrdersService(_mediatorMock.Object, _mapperMock.Object);
+    }
+
+    [Fact]
+    public async Task GetOrder_ValidId_ReturnsOrder()
+    {
+        // Arrange
+        var orderId = Guid.NewGuid();
+        var orderDto = new OrderDto
+        {
+            Id = orderId,
+            Products = []
+        };
+        var order = new Order
+        {
+            Id = orderId.ToString()
+        };
+
+        _mediatorMock.Setup(m => m.Send(It.IsAny<FindOrderByIdQuery>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(orderDto);
+
+        _mapperMock.Setup(m => m.Map<OrderDto, Order>(It.IsAny<OrderDto>())).Returns(order);
+        _mapperMock.Setup(m => m.Map<ProductDto, Product>(It.IsAny<ProductDto>())).Returns(new Product());
+
+        var requestStream = new Mock<IAsyncStreamReader<GetOrderRequest>>();
+        requestStream.SetupSequence(r => r.MoveNext(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(true)
+            .ReturnsAsync(false);
+        requestStream.Setup(r => r.Current).Returns(new GetOrderRequest { Id = orderId.ToString() });
+
+        var responseStream = new Mock<IServerStreamWriter<GetOrderResponse>>();
+        var serverCallContext = TestServerCallContext.Create("GetOrder", null, DateTime.UtcNow, [], CancellationToken.None, "127.0.0.1", null, null, null, null, null);
+
+        // Act
+        await _ordersService.GetOrder(requestStream.Object, responseStream.Object, serverCallContext);
+
+        // Assert
+        responseStream.Verify(r => r.WriteAsync(It.Is<GetOrderResponse>(response => response.Order.Id == orderId.ToString())), Times.Once);
+    }
+
+    [Fact]
+    public async Task GetOrder_InvalidId_ThrowsRpcException()
+    {
+        // Arrange
+        var requestStream = new Mock<IAsyncStreamReader<GetOrderRequest>>();
+        requestStream.SetupSequence(r => r.MoveNext(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(true)
+            .ReturnsAsync(false);
+        requestStream.Setup(r => r.Current).Returns(new GetOrderRequest { Id = "invalid-guid" });
+
+        var responseStream = new Mock<IServerStreamWriter<GetOrderResponse>>();
+        var serverCallContext = TestServerCallContext.Create("GetOrder", null, DateTime.UtcNow, [], CancellationToken.None, "127.0.0.1", null, null, null, null, null);
+
+        // Act & Assert
+        await Assert.ThrowsAsync<RpcException>(() => _ordersService.GetOrder(requestStream.Object, responseStream.Object, serverCallContext));
+    }
+}
+
+
+