generator-codedesignplus 0.0.1-rc.2

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

@@ -0,0 +1,98 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.AddProductToOrder;
+using CodeDesignPlus.Net.Microservice.Domain.ValueObjects;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.AddProductToOrder;
+
+public class AddProductToOrderCommandHandlerTest
+{
+    private readonly IUserContext user;
+
+    public AddProductToOrderCommandHandlerTest()
+    {
+        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 command = new AddProductToOrderCommand
+        (
+            Guid.NewGuid(),
+            Guid.NewGuid(),
+            "Product 1",
+            "Description Product 1",
+            100,
+            1
+        );
+
+        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
+
+        var handler = new AddProductToOrderCommandHandler(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.AddProductToOrderAsync(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);
+        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 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);
+
+        var command = new AddProductToOrderCommand
+        (
+            Guid.NewGuid(),
+            Guid.NewGuid(),
+            "Product 1",
+            "Description Product 1",
+            100,
+            1
+        );
+
+        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(order);
+
+        var handler = new AddProductToOrderCommandHandler(orderRepository.Object, this.user, pubsub.Object);
+
+        // Act
+        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);
+        pubsub.Verify(x => x.PublishAsync(It.IsAny<IReadOnlyList<IDomainEvent>>(), It.IsAny<CancellationToken>()), Times.Once);
+
+        Assert.NotEmpty(order.Products);
+        Assert.NotNull(order.UpdatedAt);
+        Assert.Equal(this.user.IdUser, order.UpdatedBy);
+        Assert.Contains(order.Products,
+            x =>
+            x.Name == command.Name &&
+            x.Description == command.Description &&
+            x.Price == command.Price &&
+            x.Quantity == command.Quantity
+        );
+    }
+
+}

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

@@ -0,0 +1,84 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.AddProductToOrder;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.AddProductToOrder;
+
+public class AddProductToOrderCommandTest
+{
+    private readonly Validator _validator;
+
+    public AddProductToOrderCommandTest()
+    {
+        _validator = new Validator();
+    }
+
+    [Fact]
+    public async Task Should_Have_Error_When_Id_Is_Empty()
+    {
+        var command = new AddProductToOrderCommand(Guid.Empty, Guid.NewGuid(), "product", "description", 1, 10);
+        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_IdProduct_Is_Empty()
+    {
+        var command = new AddProductToOrderCommand(Guid.NewGuid(), Guid.Empty, "product", "description", 1, 10);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.IdProduct) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData(null)]
+    public async Task Should_Have_Error_When_Name_Is_Invalid(string? name)
+    {
+        var command = new AddProductToOrderCommand(Guid.NewGuid(), Guid.NewGuid(), name!, "description", 1, 10);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.Name) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData(null)]
+    public async Task Should_Have_Error_When_Description_Is_Invalid(string? description)
+    {
+        var command = new AddProductToOrderCommand(Guid.NewGuid(), Guid.NewGuid(), "product", description!, 1, 10);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.Description) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(-10)]
+    public async Task Should_Have_Error_When_Price_Is_Invalid(long price)
+    {
+        var command = new AddProductToOrderCommand(Guid.NewGuid(), Guid.NewGuid(), "product", "description", price, 10);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.Price) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(-10)]
+    public async Task Should_Have_Error_When_Quantity_Is_Invalid(int quantity)
+    {
+        var command = new AddProductToOrderCommand(Guid.NewGuid(), Guid.NewGuid(), "product", "description", 1, quantity);
+        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_When_All_Properties_Are_Valid()
+    {
+        var command = new AddProductToOrderCommand(Guid.NewGuid(), Guid.NewGuid(), "product", "description", 1, 10);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Empty(result.Errors);
+    }
+}

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

@@ -0,0 +1,74 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.CancelOrder;
+using CodeDesignPlus.Net.Microservice.Domain.ValueObjects;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.CancelOrder;
+
+public class CancelOrderCommandHandlerTest
+{
+
+    private readonly IUserContext user;
+
+    public CancelOrderCommandHandlerTest()
+    {
+        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 command = new CancelOrderCommand(Guid.NewGuid(), "Reason");
+
+        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
+
+        var handler = new CancelOrderCommandHandler(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.CancelOrderAsync(It.IsAny<CancelOrderParams>(), 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 Handle_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);
+
+        var command = new CancelOrderCommand(order.Id, "Reason");
+
+        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
+
+        var handler = new CancelOrderCommandHandler(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.CancelOrderAsync(It.IsAny<CancelOrderParams>(), 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/CancelOrder/CancelOrderCommandTest.cs

@@ -0,0 +1,43 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.CancelOrder;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.CancelOrder;
+
+public class CancelOrderCommandTest
+{
+    private readonly Validator _validator;
+
+    public CancelOrderCommandTest()
+    {
+        _validator = new Validator();
+    }
+
+    [Fact]
+    public async Task Should_Have_Error_When_Id_Is_Empty()
+    {
+        var command = new CancelOrderCommand(Guid.Empty, "Reason");
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.Id) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData(null)]
+    public async Task Should_Have_Error_When_Reason_Is_Invalid(string? reason)
+    {
+        var command = new CancelOrderCommand(Guid.NewGuid(), reason!);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.Reason) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Fact]
+    public async Task Should_Not_Have_Error()
+    {
+        var command = new CancelOrderCommand(Guid.NewGuid(), "Reason");
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Empty(result.Errors);
+    }
+
+}

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

@@ -0,0 +1,74 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.CompleteOrder;
+using CodeDesignPlus.Net.Microservice.Domain.ValueObjects;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.CompleteOrder;
+
+public class CompleteOrderCommandHandlerTest
+{
+
+    private readonly IUserContext user;
+
+    public CompleteOrderCommandHandlerTest()
+    {
+        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 command = new CompleteOrderCommand(Guid.NewGuid());
+
+        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(default(OrderAggregate));
+
+        var handler = new CompleteOrderCommandHandler(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.CompleteOrderAsync(It.IsAny<CompleteOrderParams>(),  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 Handle_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);
+
+        var command = new CompleteOrderCommand(order.Id);
+
+        orderRepository.Setup(x => x.FindAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))!.ReturnsAsync(order);
+
+        var handler = new CompleteOrderCommandHandler(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.CompleteOrderAsync(It.IsAny<CompleteOrderParams>(),  It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+}

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

@@ -0,0 +1,32 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.CompleteOrder;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.CompleteOrder;
+
+public class CompleteOrderCommandTest
+{
+
+    private readonly Validator _validator;
+
+    public CompleteOrderCommandTest()
+    {
+        _validator = new Validator();
+    }
+
+    [Fact]
+    public async Task Should_Have_Error_When_Id_Is_Empty()
+    {
+        var command = new CompleteOrderCommand(Guid.Empty);
+        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_Not_Have_Error()
+    {
+        var command = new CompleteOrderCommand(Guid.NewGuid());
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Empty(result.Errors);
+    }
+}

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

@@ -0,0 +1,100 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.CreateOrder;
+using CodeDesignPlus.Net.Microservice.Domain.ValueObjects;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.CreateOrder;
+
+public class CreateOrderCommandHandlerTest
+{
+    private Mock<IUserContext> userMock;
+
+    public CreateOrderCommandHandlerTest()
+    {
+        this.userMock = new Mock<IUserContext>();
+
+        userMock.Setup(x => x.IdUser).Returns(Guid.NewGuid());
+        userMock.Setup(x => x.Tenant).Returns(Guid.NewGuid());
+    }
+
+    [Fact]
+    public async Task Handle_OrderAlreadyExists_ThrowApplicaionException()
+    {
+        // Arrange
+        var orderRepository = new Mock<IOrderRepository>();
+        var pubsub = new Mock<IPubSub>();
+        
+        var clientValueObject = ClientValueObject.Create(Guid.NewGuid(), "Client", "1234567890", "CC");
+        var addressValueObject = AddressValueObject.Create("Colombia", "Bogota", "Bogota", "Calle 123", 123456);
+
+        var client = new ClientDto()
+        {
+            Id = Guid.NewGuid(),
+            Name = "Client",
+            Document = "1234567890",
+            TypeDocument = "CC"
+        };
+        var address = new AddressDto(){
+            Country = "Colombia",
+            State = "Bogota",
+            City = "Bogota",
+            Address = "Calle 123",
+            CodePostal = 123456
+        };
+
+        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));
+
+        var handler = new CreateOrderCommandHandler(orderRepository.Object, this.userMock.Object, 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);
+        pubsub.Verify(x => x.PublishAsync(It.IsAny<IReadOnlyList<IDomainEvent>>(), It.IsAny<CancellationToken>()), Times.Never);
+
+        Assert.Equal(Errors.OrderAlreadyExists.GetCode(), exception.Code);
+        Assert.Equal(Errors.OrderAlreadyExists.GetMessage(), exception.Message);
+    }
+
+    [Fact]
+    public async Task Handle_Success()
+    {
+        // Arrange
+        var orderRepository = new Mock<IOrderRepository>();
+        var pubsub = new Mock<IPubSub>();
+
+        var client = new ClientDto()
+        {
+            Id = Guid.NewGuid(),
+            Name = "Client",
+            Document = "1234567890",
+            TypeDocument = "CC"
+        };
+        var address = new AddressDto(){
+            Country = "Colombia",
+            State = "Bogota",
+            City = "Bogota",
+            Address = "Calle 123",
+            CodePostal = 123456
+        };
+
+
+        var command = new CreateOrderCommand(Guid.NewGuid(), client, address);
+
+        var handler = new CreateOrderCommandHandler(orderRepository.Object, this.userMock.Object, pubsub.Object);
+
+        // Act
+        await handler.Handle(command, CancellationToken.None);
+
+        // Assert
+        orderRepository.Verify(x => x.CreateOrderAsync(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/CreateOrder/CreateOrderCommandTest.cs

@@ -0,0 +1,122 @@
+using CodeDesignPlus.Net.Microservice.Application.Order.Commands.CreateOrder;
+
+namespace CodeDesignPlus.Net.Microservice.Application.Test.Order.Commands.CreateOrder;
+
+public class CreateOrderCommandTest
+{
+    private readonly Validator _validator;
+
+    public CreateOrderCommandTest()
+    {
+        _validator = new Validator();
+    }
+
+    [Fact]
+    public async Task Should_Have_Error_When_Client_Is_Null()
+    {
+        var address = new AddressDto()
+        {
+            Country = "Colombia",
+            State = "Bogota",
+            City = "Bogota",
+            Address = "Calle 123",
+            CodePostal = 123456
+        };
+        var command = new CreateOrderCommand(Guid.NewGuid(), null!, address);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.Client) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Fact]
+    public async Task Should_Have_Error_When_Address_Is_Null()
+    {
+        var client = new ClientDto()
+        {
+            Id = Guid.NewGuid(),
+            Name = "Client",
+            Document = "1234567890",
+            TypeDocument = "CC"
+        };
+        var command = new CreateOrderCommand(Guid.NewGuid(), client, null!);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == nameof(command.Address) && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData(null)]
+    public async Task Should_Have_Error_When_ClientName_Is_Invalid(string? client)
+    {
+        var address = new AddressDto()
+        {
+            Country = "Colombia",
+            State = "Bogota",
+            City = "Bogota",
+            Address = "Calle 123",
+            CodePostal = 123456
+        };
+
+        var command = new CreateOrderCommand(Guid.NewGuid(), new ClientDto()
+        {
+            Name = client!,
+            Document = "1234567890",
+            TypeDocument = "CC"
+        }, address);
+
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == $"{nameof(CreateOrderCommand.Client)}.{nameof(CreateOrderCommand.Client.Id)}" && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Fact]
+    public async Task Shoul_Have_Error_When_ClientId_Is_Empty()
+    {
+        var address = new AddressDto()
+        {
+            Country = "Colombia",
+            State = "Bogota",
+            City = "Bogota",
+            Address = "Calle 123",
+            CodePostal = 123456
+        };
+
+        var command = new CreateOrderCommand(Guid.NewGuid(), new ClientDto()
+        {
+            Id = Guid.Empty,
+            Name = "Client",
+            Document = "1234567890",
+            TypeDocument = "CC"
+        }, address);
+
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Contains(result.Errors, x => x.PropertyName == $"{nameof(command.Client)}.{nameof(command.Client.Id)}" && !string.IsNullOrEmpty(x.ErrorMessage));
+    }
+
+    [Fact]
+    public async Task Should_Not_Have_Error()
+    {
+        var address = new AddressDto()
+        {
+            Country = "Colombia",
+            State = "Bogota",
+            City = "Bogota",
+            Address = "Calle 123",
+            CodePostal = 123456
+        };
+
+        var command = new CreateOrderCommand(Guid.NewGuid(), new ClientDto()
+        {
+            Id = Guid.NewGuid(),
+            Name = "Client",
+            Document = "1234567890",
+            TypeDocument = "CC"
+        }, address);
+        var result = await _validator.ValidateAsync(command);
+
+        Assert.Empty(result.Errors);
+    }
+
+}