generator-codedesignplus 0.1.0-alpha.1 → 0.1.0-alpha.5

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

@@ -9,18 +9,18 @@
     <SonarQubeExclude>true</SonarQubeExclude>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="coverlet.msbuild" Version="6.0.3">
+    <PackageReference Include="coverlet.msbuild" Version="6.0.4">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.3">
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
       <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">
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

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

@@ -34,7 +34,7 @@ public class AddProductToOrderCommandHandlerTest
             1
         );
 
-        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
+        orderRepository.Setup(x => x.FindAsync<OrderAggregate>(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
 
         var handler = new AddProductToOrderCommandHandler(orderRepository.Object, this.user, pubsub.Object);
 
@@ -42,8 +42,8 @@ public class AddProductToOrderCommandHandlerTest
         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.AddProductToOrderAsync(It.IsAny<AddProductToOrderParams>(), It.IsAny<CancellationToken>()), Times.Never);
+        orderRepository.Verify(x => x.FindAsync<OrderAggregate>(command.Id, this.user.Tenant, It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.AddProductToOrderAsync(command.Id, this.user.Tenant, It.IsAny<AddProductToOrderParams>(), 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);
@@ -71,7 +71,7 @@ public class AddProductToOrderCommandHandlerTest
             1
         );
 
-        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(order);
+        orderRepository.Setup(x => x.FindAsync<OrderAggregate>(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(order);
 
         var handler = new AddProductToOrderCommandHandler(orderRepository.Object, this.user, pubsub.Object);
 
@@ -79,8 +79,8 @@ public class AddProductToOrderCommandHandlerTest
         await handler.Handle(command, CancellationToken.None);
 
         // Assert
-        orderRepository.Verify(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()), Times.Once);
-        orderRepository.Verify(x => x.AddProductToOrderAsync(It.IsAny<AddProductToOrderParams>(), It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.FindAsync<OrderAggregate>(command.Id, this.user.Tenant, It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.AddProductToOrderAsync(order.Id, this.user.Tenant, It.IsAny<AddProductToOrderParams>(), It.IsAny<CancellationToken>()), Times.Once);
         pubsub.Verify(x => x.PublishAsync(It.IsAny<IReadOnlyList<IDomainEvent>>(), It.IsAny<CancellationToken>()), Times.Once);
 
         Assert.NotEmpty(order.Products);

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

@@ -5,7 +5,6 @@ namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.Cancel
 
 public class CancelOrderCommandHandlerTest
 {
-
     private readonly IUserContext user;
 
     public CancelOrderCommandHandlerTest()
@@ -27,7 +26,7 @@ public class CancelOrderCommandHandlerTest
 
         var command = new CancelOrderCommand(Guid.NewGuid(), "Reason");
 
-        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
+        orderRepository.Setup(x => x.FindAsync<OrderAggregate>(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
 
         var handler = new CancelOrderCommandHandler(orderRepository.Object, this.user, pubsub.Object);
 
@@ -35,8 +34,8 @@ public class CancelOrderCommandHandlerTest
         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.CancelOrderAsync(It.IsAny<CancelOrderParams>(), It.IsAny<CancellationToken>()), Times.Never);
+        orderRepository.Verify(x => x.FindAsync<OrderAggregate>(command.Id, this.user.Tenant, It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.CancelOrderAsync(It.IsAny<CancelOrderParams>(), this.user.Tenant, 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);
@@ -56,7 +55,7 @@ public class CancelOrderCommandHandlerTest
 
         var command = new CancelOrderCommand(order.Id, "Reason");
 
-        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
+        orderRepository.Setup(x => x.FindAsync<OrderAggregate>(It.IsAny<Guid>(), It.IsAny<Guid>(),It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
 
         var handler = new CancelOrderCommandHandler(orderRepository.Object, this.user, pubsub.Object);
 
@@ -66,8 +65,8 @@ public class CancelOrderCommandHandlerTest
         // 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.CancelOrderAsync(It.IsAny<CancelOrderParams>(), It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.FindAsync<OrderAggregate>(command.Id, this.user.Tenant, It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.CancelOrderAsync(It.IsAny<CancelOrderParams>(),this.user.Tenant, 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/CompleteOrder/CompleteOrderCommandHandlerTest.cs

@@ -28,7 +28,7 @@ public class CompleteOrderCommandHandlerTest
 
         var command = new CompleteOrderCommand(Guid.NewGuid());
 
-        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
+        orderRepository.Setup(x => x.FindAsync<OrderAggregate>(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
 
         var handler = new CompleteOrderCommandHandler(orderRepository.Object, this.user, pubsub.Object);
 
@@ -36,8 +36,8 @@ public class CompleteOrderCommandHandlerTest
         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.CompleteOrderAsync(It.IsAny<CompleteOrderParams>(),  It.IsAny<CancellationToken>()), Times.Never);
+        orderRepository.Verify(x => x.FindAsync<OrderAggregate>(command.Id, this.user.Tenant, It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.CompleteOrderAsync(It.IsAny<CompleteOrderParams>(), this.user.Tenant, 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);
@@ -57,7 +57,7 @@ public class CompleteOrderCommandHandlerTest
 
         var command = new CompleteOrderCommand(order.Id);
 
-        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
+        orderRepository.Setup(x => x.FindAsync<OrderAggregate>(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
 
         var handler = new CompleteOrderCommandHandler(orderRepository.Object, this.user, pubsub.Object);
 
@@ -67,8 +67,8 @@ public class CompleteOrderCommandHandlerTest
         // 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.CompleteOrderAsync(It.IsAny<CompleteOrderParams>(),  It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.FindAsync<OrderAggregate>(command.Id, this.user.Tenant, It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.CompleteOrderAsync(It.IsAny<CompleteOrderParams>(), this.user.Tenant, It.IsAny<CancellationToken>()), Times.Once);
     }
 
 }

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

@@ -5,14 +5,16 @@ namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.Create
 
 public class CreateOrderCommandHandlerTest
 {
-    private Mock<IUserContext> userMock;
+    private readonly IUserContext user;
 
     public CreateOrderCommandHandlerTest()
     {
-        this.userMock = new Mock<IUserContext>();
+        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]
@@ -43,17 +45,17 @@ public class CreateOrderCommandHandlerTest
         var command = new CreateOrderCommand(Guid.NewGuid(), client, address);
 
         orderRepository
-            .Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!
-            .ReturnsAsync(OrderAggregate.Create(Guid.NewGuid(), clientValueObject, addressValueObject, this.userMock.Object.Tenant, this.userMock.Object.IdUser));
+            .Setup(x => x.ExistsAsync<OrderAggregate>(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(true);
 
-        var handler = new CreateOrderCommandHandler(orderRepository.Object, this.userMock.Object, pubsub.Object);
+        var handler = new CreateOrderCommandHandler(orderRepository.Object, this.user, pubsub.Object);
 
         // Act
         var exception = await Assert.ThrowsAsync<Exceptions.CodeDesignPlusException>(() => handler.Handle(command, CancellationToken.None));
 
         // Assert
-        orderRepository.Verify(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()), Times.Once);
-        orderRepository.Verify(x => x.CreateOrderAsync(It.IsAny<OrderAggregate>(), It.IsAny<CancellationToken>()), Times.Never);
+        orderRepository.Verify(x => x.ExistsAsync<OrderAggregate>(command.Id, this.user.Tenant, It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.CreateAsync(It.IsAny<OrderAggregate>(), It.IsAny<CancellationToken>()), Times.Never);
         pubsub.Verify(x => x.PublishAsync(It.IsAny<IReadOnlyList<IDomainEvent>>(), It.IsAny<CancellationToken>()), Times.Never);
 
         Assert.Equal(Errors.OrderAlreadyExists.GetCode(), exception.Code);
@@ -85,16 +87,14 @@ public class CreateOrderCommandHandlerTest
 
         var command = new CreateOrderCommand(Guid.NewGuid(), client, address);
 
-        var handler = new CreateOrderCommandHandler(orderRepository.Object, this.userMock.Object, pubsub.Object);
+        var handler = new CreateOrderCommandHandler(orderRepository.Object, this.user, pubsub.Object);
 
         // Act
         await handler.Handle(command, CancellationToken.None);
 
         // Assert
-        orderRepository.Verify(x => x.CreateOrderAsync(It.IsAny<OrderAggregate>(), It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.CreateAsync(It.IsAny<OrderAggregate>(), It.IsAny<CancellationToken>()), Times.Once);
         pubsub.Verify(x => x.PublishAsync(It.IsAny<IReadOnlyList<IDomainEvent>>(), It.IsAny<CancellationToken>()), Times.Once);
-        userMock.Verify(x => x.Tenant, Times.Once);
-        userMock.Verify(x => x.IdUser, Times.Once);
     }
 
 }

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

@@ -5,14 +5,16 @@ namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.Remove
 
 public class RemoveProductCommandHandlerTest
 {
+    private readonly Guid idUser = Guid.NewGuid();
+    private readonly Guid tenant = Guid.NewGuid();
     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());
+        userMock.Setup(x => x.IdUser).Returns(idUser);
+        userMock.Setup(x => x.Tenant).Returns(tenant);
 
         this.user = userMock.Object;
     }
@@ -26,7 +28,7 @@ public class RemoveProductCommandHandlerTest
         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!);
+        orderRepository.Setup(x => x.FindAsync<OrderAggregate>(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync((OrderAggregate)null!);
 
         // Act
         var exception = await Assert.ThrowsAsync<CodeDesignPlusException>(() => handler.Handle(request, CancellationToken.None));
@@ -56,7 +58,7 @@ public class RemoveProductCommandHandlerTest
             Quantity = 1
         });
 
-        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
+        orderRepository.Setup(x => x.FindAsync<OrderAggregate>(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
 
         // Act
         await handler.Handle(request, CancellationToken.None);
@@ -64,7 +66,7 @@ public class RemoveProductCommandHandlerTest
         // 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);
+        orderRepository.Verify(x => x.RemoveProductFromOrderAsync(It.IsAny<RemoveProductFromOrderParams>(), this.user.Tenant, 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/UpdateQuantityProductCommandHandlerTest.cs

@@ -26,7 +26,7 @@ public class UpdateQuantityProductCommandHandlerTest
 
         var command = new UpdateQuantityProductCommand(Guid.NewGuid(), Guid.NewGuid(), 1);
 
-        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
+        orderRepository.Setup(x => x.FindAsync<OrderAggregate>(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
 
         var handler = new UpdateQuantityProductCommandHandler(orderRepository.Object, this.user, pubsub.Object);
 
@@ -34,8 +34,8 @@ public class UpdateQuantityProductCommandHandlerTest
         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);
+        orderRepository.Verify(x => x.FindAsync<OrderAggregate>(command.Id, this.user.Tenant, It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.UpdateQuantityProductAsync(command.Id, this.user.Tenant, 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);
@@ -64,7 +64,7 @@ public class UpdateQuantityProductCommandHandlerTest
 
         var command = new UpdateQuantityProductCommand(order.Id, order.Products[0].Id, 2);
 
-        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
+        orderRepository.Setup(x => x.FindAsync<OrderAggregate>(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
 
         var handler = new UpdateQuantityProductCommandHandler(orderRepository.Object, this.user, pubsub.Object);
 
@@ -74,8 +74,8 @@ public class UpdateQuantityProductCommandHandlerTest
         // 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);
+        orderRepository.Verify(x => x.FindAsync<OrderAggregate>(command.Id, this.user.Tenant, It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.UpdateQuantityProductAsync(command.Id, this.user.Tenant, 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/Queries/FindOrderById/FindOrderByIdQueryHandlerTest.cs

@@ -5,6 +5,18 @@ namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Queries.FindOrd
 
 public class FindOrderByIdQueryHandlerTest
 {
+    private readonly IUserContext user;
+
+    public FindOrderByIdQueryHandlerTest()
+    {
+        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_ValidId_ReturnsOrderDto()
     {
@@ -13,7 +25,7 @@ public class FindOrderByIdQueryHandlerTest
         var mapper = new Mock<IMapper>();
         var query = new FindOrderByIdQuery(Guid.NewGuid());
         var cancellationToken = new CancellationToken();
-        var dtoExpected = new OrderDto();        
+        var dtoExpected = new OrderDto();
         var cacheManagerMock = new Mock<ICacheManager>();
 
         cacheManagerMock.Setup(x => x.ExistsAsync(It.IsAny<string>())).ReturnsAsync(false);
@@ -21,7 +33,7 @@ public class FindOrderByIdQueryHandlerTest
 
         mapper.Setup(x => x.Map<OrderDto>(It.IsAny<object>())).Returns(dtoExpected);
 
-        var handler = new FindOrderByIdQueryHandler(orderRepository.Object, mapper.Object, cacheManagerMock.Object);
+        var handler = new FindOrderByIdQueryHandler(orderRepository.Object, mapper.Object, cacheManagerMock.Object, this.user);
 
         // Act
         var result = await handler.Handle(query, cancellationToken);
@@ -30,13 +42,13 @@ public class FindOrderByIdQueryHandlerTest
         Assert.NotNull(result);
         Assert.IsType<OrderDto>(result);
         Assert.Equal(dtoExpected, result);
-        orderRepository.Verify(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()), Times.Once);
+        orderRepository.Verify(x => x.FindAsync<OrderAggregate>(query.Id, this.user.Tenant, 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()
     {
@@ -53,7 +65,7 @@ public class FindOrderByIdQueryHandlerTest
 
         mapper.Setup(x => x.Map<OrderDto>(It.IsAny<object>())).Returns(dtoExpected);
 
-        var handler = new FindOrderByIdQueryHandler(orderRepository.Object, mapper.Object, cacheManagerMock.Object);
+        var handler = new FindOrderByIdQueryHandler(orderRepository.Object, mapper.Object, cacheManagerMock.Object, this.user);
 
         // Act
         var result = await handler.Handle(query, cancellationToken);
@@ -62,7 +74,7 @@ public class FindOrderByIdQueryHandlerTest
         Assert.NotNull(result);
         Assert.IsType<OrderDto>(result);
         Assert.Equal(dtoExpected, result);
-        orderRepository.Verify(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()), Times.Never);
+        orderRepository.Verify(x => x.FindAsync<OrderAggregate>(query.Id, this.user.Tenant, 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

@@ -9,6 +9,7 @@ public class GetAllOrdersQueryHandlerTest
     public async Task Handle_Success()
     {
         // Arrange
+        var tenant = Guid.NewGuid();
         var criteria = new C.Criteria();
         var query = new GetAllOrdersQuery(criteria);
         var orders = new List<OrderDto>
@@ -21,9 +22,9 @@ public class GetAllOrdersQueryHandlerTest
                     TypeDocument = "CC",
                     Id = Guid.NewGuid()
                 },
-                CompletedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                CompletedAt = SystemClock.Instance.GetCurrentInstant(),
                 CreatedBy = Guid.NewGuid(),
-                CreatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                CreatedAt = SystemClock.Instance.GetCurrentInstant(),
                 IsActive = true,
                 Products = [
                     new(){
@@ -33,7 +34,6 @@ public class GetAllOrdersQueryHandlerTest
                         Quantity = 1
                     }
                 ],
-
             },
             new() {
                 Id = Guid.NewGuid(),
@@ -43,9 +43,9 @@ public class GetAllOrdersQueryHandlerTest
                     TypeDocument = "CC",
                     Id = Guid.NewGuid()
                 },
-                CompletedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                CompletedAt = SystemClock.Instance.GetCurrentInstant(),
                 CreatedBy = Guid.NewGuid(),
-                CreatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                CreatedAt = SystemClock.Instance.GetCurrentInstant(),
                 IsActive = true,
                 Products = [
                     new(){
@@ -61,7 +61,11 @@ public class GetAllOrdersQueryHandlerTest
 
         var orderRepositoryMock = new Mock<IOrderRepository>();
         var mapperMock = new Mock<IMapper>();
-        var queryHandler = new GetAllOrdersQueryHandler(orderRepositoryMock.Object, mapperMock.Object);
+        var userContextMock = new Mock<IUserContext>();
+
+        userContextMock.SetupGet(x => x.Tenant).Returns(tenant);
+
+        var queryHandler = new GetAllOrdersQueryHandler(orderRepositoryMock.Object, mapperMock.Object, userContextMock.Object);
 
         mapperMock.Setup(x => x.Map<List<OrderDto>>(It.IsAny<List<OrderAggregate>>())).Returns(orders);
 
@@ -73,7 +77,7 @@ public class GetAllOrdersQueryHandlerTest
         Assert.NotEmpty(result);
         Assert.Equal(orders.Count, result.Count);
 
-        orderRepositoryMock.Verify(x => x.MatchingAsync<OrderAggregate>(criteria, It.IsAny<CancellationToken>()), Times.Once);
+        orderRepositoryMock.Verify(x => x.MatchingAsync<OrderAggregate>(criteria, tenant, 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/Usings.cs

@@ -9,6 +9,7 @@ global using Mapster;
 global using MapsterMapper;
 global using C = CodeDesignPlus.Net.Core.Abstractions.Models.Criteria;
 global using CodeDesignPlus.Net.Serializers;
+global using NodaTime;
 
 global using CodeDesignPlus.Net.Microservice.Application.Order.DataTransferObjects;
 global using CodeDesignPlus.Net.Microservice.Domain.Enums;

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

@@ -9,19 +9,19 @@
     <SonarQubeExclude>true</SonarQubeExclude>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="coverlet.msbuild" Version="6.0.3">
+    <PackageReference Include="coverlet.msbuild" Version="6.0.4">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.3">
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
       <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="CodeDesignPlus.Net.xUnit.Microservice" Version="0.5.0-beta.81" />
     <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">
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

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

@@ -1,7 +1,6 @@
 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;
 

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

@@ -6,25 +6,25 @@
     <IsPackable>false</IsPackable>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="CodeDesignPlus.Net.Serializers" Version="0.5.0-beta.60" />
-    <PackageReference Include="coverlet.msbuild" Version="6.0.3">
+    <PackageReference Include="CodeDesignPlus.Net.Serializers" Version="0.5.0-beta.81" />
+    <PackageReference Include="coverlet.msbuild" Version="6.0.4">
       <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">
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.3">
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
       <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" />
+    <PackageReference Include="CodeDesignPlus.Net.xUnit.Microservice" Version="0.5.0-beta.81" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\src\domain\CodeDesignPlus.Net.Microservice.Infrastructure\CodeDesignPlus.Net.Microservice.Infrastructure.csproj" />

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

@@ -9,17 +9,17 @@
     <SonarQubeExclude>true</SonarQubeExclude>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="coverlet.msbuild" Version="6.0.3">
+    <PackageReference Include="coverlet.msbuild" Version="6.0.4">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.3">
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.0">
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Domain.Test/DomainEvents/OrderCancelledDomainEventTest.cs

@@ -17,7 +17,7 @@ public class OrderCancelledDomainEventTest
         Assert.NotNull(domainEvent);
         Assert.Equal(aggregateId, domainEvent.AggregateId);
         Assert.Equal(reason, domainEvent.Reason);
-        Assert.True(domainEvent.CancelledAt > 0);
+        Assert.True(domainEvent.CancelledAt > Instant.MinValue);
     }
 
     [Fact]
@@ -27,8 +27,8 @@ public class OrderCancelledDomainEventTest
         var eventId = Guid.NewGuid();
         var aggregateId = Guid.NewGuid();
         var reason = "Some reason";
-        var cancelledAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
-        var occurredAt = DateTime.UtcNow;
+        var cancelledAt = SystemClock.Instance.GetCurrentInstant();
+        var occurredAt = SystemClock.Instance.GetCurrentInstant();
         var metadata = new Dictionary<string, object>();
 
         // Act

package/generators/microservice/templates/microservice/tests/unit/CodeDesignPlus.Net.Microservice.Domain.Test/OrderAggregateTest.cs

@@ -122,7 +122,7 @@ public class OrderAggregateTest
         Assert.Equal(shippingAddress.CodePostal, @event.ShippingAddress.CodePostal);
         Assert.Equal(tenant, @event.Tenant);
         Assert.Equal(OrderStatus.Created, @event.OrderStatus);
-        Assert.NotEqual(0, @event.CreatedAt);
+        Assert.True(@event.CreatedAt > Instant.MinValue);
     }
 
     [Fact]
@@ -461,7 +461,7 @@ public class OrderAggregateTest
 
         Assert.NotNull(@event);
         Assert.Equal(orderAggregate.Id, @event.AggregateId);
-        Assert.NotEqual(0, @event.CompletedAt);
+        Assert.True(@event.CompletedAt > Instant.MinValue);
 
         Assert.NotNull(orderAggregate.UpdatedAt);
         Assert.Equal(updatedBy, orderAggregate.UpdatedBy);

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

@@ -2,6 +2,8 @@ global using System;
 global using CodeDesignPlus.Net.Exceptions;
 global using CodeDesignPlus.Net.Exceptions.Extensions;
 global using CodeDesignPlus.Net.Serializers;
+global using NodaTime;
+
 
 global using CodeDesignPlus.Net.Microservice.Domain.DomainEvents;
 global using CodeDesignPlus.Net.Microservice.Domain.Enums;

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

@@ -9,18 +9,18 @@
     <SonarQubeExclude>true</SonarQubeExclude>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="coverlet.msbuild" Version="6.0.3">
+    <PackageReference Include="coverlet.msbuild" Version="6.0.4">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.3">
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
       <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">
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>