Skip to content

Open-source eCommerce platform for C# and ASP.NET Core 10 with MongoDB. Build multi-store shops and multi-vendor marketplaces with B2B/B2C, REST API, plugins, Vue 3 and Docker.

Add tests

support817dfbe7d302
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/AddCustomerReservationCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/AddCustomerReservationCommandHandlerTests.cs
new file mode 100644
index 000000000..4060a087e
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/AddCustomerReservationCommandHandlerTests.cs
@@ -0,0 +1,60 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Grand.Business.Checkout.Commands.Handlers.Orders;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Moq;
+using Grand.Domain;
+using Grand.Domain.Catalog;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class AddCustomerReservationCommandHandlerTests
+ {
+ private AddCustomerReservationCommandHandler _handler;
+ private Mock<IProductReservationService> _productReservationServiceMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _productReservationServiceMock = new Mock<IProductReservationService>();
+ _handler = new AddCustomerReservationCommandHandler(_productReservationServiceMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new Core.Commands.Checkout.Orders.AddCustomerReservationCommand();
+ command.Customer = new Domain.Customers.Customer();
+ command.RentalStartDate = DateTime.UtcNow.AddDays(1).Date;
+ command.RentalEndDate = DateTime.UtcNow.AddDays(2).Date;
+ command.Product = new Domain.Catalog.Product() {
+ IncBothDate = true,
+ IntervalUnitId = IntervalUnit.Day
+ };
+ command.ShoppingCartItem = new Domain.Orders.ShoppingCartItem() { };
+
+ _productReservationServiceMock.Setup(c => c.GetProductReservationsByProductId(It.IsAny<string>(), true, null, 0, int.MaxValue)).Returns(() => Task.FromResult((IPagedList<ProductReservation>)
+ new PagedList<ProductReservation>() {
+ new ProductReservation() { Date = DateTime.UtcNow.AddDays(4).Date, Resource = "" },
+ new ProductReservation() { Date = DateTime.UtcNow.AddDays(3).Date, Resource = "" },
+ new ProductReservation() { Date = DateTime.UtcNow.AddDays(2).Date, Resource = "" },
+ new ProductReservation() { Date = DateTime.UtcNow.AddDays(1).Date, Resource = "" },
+ new ProductReservation() { Date = DateTime.UtcNow.Date, Resource = "" } }
+ ));
+
+ _productReservationServiceMock.Setup(c => c.GetCustomerReservationsHelpers(It.IsAny<string>())).ReturnsAsync((IList<CustomerReservationsHelper>)
+ new List<CustomerReservationsHelper>() { });
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+
+ //Assert
+ _productReservationServiceMock.Verify(c => c.InsertCustomerReservationsHelper(It.IsAny<CustomerReservationsHelper>()));
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/AddRequiredProductsCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/AddRequiredProductsCommandHandlerTests.cs
new file mode 100644
index 000000000..213132c55
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/AddRequiredProductsCommandHandlerTests.cs
@@ -0,0 +1,57 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Grand.Business.Checkout.Commands.Handlers.Orders;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Moq;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Domain.Orders;
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Grand.Domain.Catalog;
+using Grand.Domain.Customers;
+using Grand.Business.Core.Utilities.Checkout;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class AddRequiredProductsCommandHandlerTests
+ {
+ private AddRequiredProductsCommandHandler _handler;
+ private Mock<IShoppingCartService> _shoppingCartServiceMock;
+ private ShoppingCartSettings _shoppingCartSettings;
+ private Mock<IProductService> _productServiceMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _shoppingCartServiceMock = new Mock<IShoppingCartService>();
+ _shoppingCartSettings = new ShoppingCartSettings();
+ _productServiceMock = new Mock<IProductService>();
+ _handler = new AddRequiredProductsCommandHandler(_shoppingCartServiceMock.Object, _shoppingCartSettings, _productServiceMock.Object);
+
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new Core.Commands.Checkout.Orders.AddRequiredProductsCommand();
+ command.Customer = new Domain.Customers.Customer();
+ command.Customer.ShoppingCartItems.Add(new ShoppingCartItem() { ProductId = "1", ShoppingCartTypeId = ShoppingCartType.ShoppingCart, StoreId = "" });
+ command.Product = new Domain.Catalog.Product() { Id = "1", RequireOtherProducts = true, RequiredProductIds = "2,3", AutoAddRequiredProducts = true };
+ command.ShoppingCartType = ShoppingCartType.ShoppingCart;
+ command.StoreId = "";
+
+ _productServiceMock.Setup(a => a.GetProductById("2", false)).Returns(() => Task.FromResult(new Product() { Id = "2", Published = true, Price = 10 }));
+ _productServiceMock.Setup(a => a.GetProductById("3", false)).Returns(() => Task.FromResult(new Product() { Id = "3", Published = true, Price = 10 }));
+
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+
+ //Assert
+ _shoppingCartServiceMock.Verify(c => c.AddToCart(It.IsAny<Customer>(), It.IsAny<string>(), ShoppingCartType.ShoppingCart, "", null, null,null, null, null, 1, false, "", "", "", It.IsAny<ShoppingCartValidatorOptions>()), Times.AtLeastOnce);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/AwardLoyaltyPointsCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/AwardLoyaltyPointsCommandHandlerTests.cs
new file mode 100644
index 000000000..dd8b3ca9f
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/AwardLoyaltyPointsCommandHandlerTests.cs
@@ -0,0 +1,60 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Common.Directory;
+using Grand.Business.Core.Interfaces.Common.Localization;
+using Grand.Business.Core.Interfaces.Customers;
+using MediatR;
+using Moq;
+using Grand.Domain.Customers;
+using Grand.Domain.Directory;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class AwardLoyaltyPointsCommandHandlerTests
+ {
+ private AwardLoyaltyPointsCommandHandler _handler;
+ private Mock<ICustomerService> _customerServiceMock;
+ private Mock<ILoyaltyPointsService> _loyaltyPointsServiceMock;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<ITranslationService> _translationServiceMock;
+ private Mock<ICurrencyService> _currencyServiceMock;
+
+
+ [TestInitialize]
+ public void Init()
+ {
+ _customerServiceMock = new Mock<ICustomerService>();
+ _loyaltyPointsServiceMock = new Mock<ILoyaltyPointsService>();
+ _mediatorMock = new Mock<IMediator>();
+ _currencyServiceMock = new Mock<ICurrencyService>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _translationServiceMock = new Mock<ITranslationService>();
+
+ _handler = new AwardLoyaltyPointsCommandHandler(_customerServiceMock.Object, _loyaltyPointsServiceMock.Object, _mediatorMock.Object, _orderServiceMock.Object, _translationServiceMock.Object, _currencyServiceMock.Object);
+ }
+
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new AwardLoyaltyPointsCommand();
+ command.Order = new Domain.Orders.Order() { StoreId = "", OrderNumber = 1 };
+ var expectedCustomer = new Customer() { Username = "John", Active = true };
+ _customerServiceMock.Setup(c => c.GetCustomerById(It.IsAny<string>())).Returns(() => Task.FromResult(expectedCustomer));
+ _currencyServiceMock.Setup(c => c.GetCurrencyByCode(It.IsAny<string>())).Returns(() => Task.FromResult(new Domain.Directory.Currency()));
+ _currencyServiceMock.Setup(c => c.ConvertToPrimaryStoreCurrency(100, It.IsAny<Currency>())).Returns(() => Task.FromResult((double)100));
+ _translationServiceMock.Setup(x => x.GetResource(It.IsAny<string>())).Returns("Name");
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CalculateLoyaltyPointsCommand>(), default)).Returns(Task.FromResult(100));
+
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+
+ //Assert
+ _loyaltyPointsServiceMock.Verify(c => c.AddLoyaltyPointsHistory(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<double>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CancelOrderItemCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CancelOrderItemCommandHandlerTests.cs
new file mode 100644
index 000000000..0461b6b91
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CancelOrderItemCommandHandlerTests.cs
@@ -0,0 +1,54 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Shipping;
+using Grand.Domain.Catalog;
+using Grand.Domain.Common;
+using Grand.Domain.Orders;
+using Grand.Domain.Shipping;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class CancelOrderItemCommandHandlerTests
+ {
+
+
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IShipmentService> _shipmentServiceMock;
+ private Mock<IProductService> _productServiceMock;
+ private Mock<IInventoryManageService> _inventoryMock;
+ private CancelOrderItemCommandHandler _handler;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _shipmentServiceMock = new Mock<IShipmentService>();
+ _productServiceMock = new Mock<IProductService>();
+ _inventoryMock = new Mock<IInventoryManageService>();
+ _handler = new CancelOrderItemCommandHandler(_mediatorMock.Object, _orderServiceMock.Object, _shipmentServiceMock.Object,
+ _productServiceMock.Object, _inventoryMock.Object);
+ }
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ var command = new CancelOrderItemCommand();
+ command.Order = new Order() {
+ Id = "id"
+ };
+ command.OrderItem = new OrderItem() { OpenQty = 1, Status = OrderItemStatus.Open };
+
+ _shipmentServiceMock.Setup(c => c.GetShipmentsByOrder(It.IsAny<string>())).ReturnsAsync(new List<Shipment>());
+ _productServiceMock.Setup(a => a.GetProductById(It.IsAny<string>(), false)).Returns(() => Task.FromResult(new Product() { Id = "2", Published = true, Price = 10 }));
+ await _handler.Handle(command, default);
+
+ _inventoryMock.Verify(c => c.AdjustReserved(It.IsAny<Product>(), It.IsAny<int>(), It.IsAny<IList<CustomAttribute>>(), It.IsAny<string>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CaptureCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CaptureCommandHandlerTests.cs
new file mode 100644
index 000000000..71b60551c
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CaptureCommandHandlerTests.cs
@@ -0,0 +1,52 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Grand.Business.Checkout.Commands.Handlers.Orders;
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Domain.Orders;
+using Grand.Domain.Payments;
+using MediatR;
+using Moq;
+using Grand.Business.Core.Interfaces.Checkout.Payments;
+using Grand.Business.Core.Interfaces.Common.Logging;
+using Grand.Business.Core.Queries.Checkout.Orders;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class CaptureCommandHandlerTests
+ {
+ private CaptureCommandHandler _handler;
+
+ private Mock<IPaymentService> _paymentServiceMock;
+ private Mock<IPaymentTransactionService> _paymentTransactionMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<ILogger> _loggerMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _loggerMock = new Mock<ILogger>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _paymentServiceMock = new Mock<IPaymentService>();
+ _paymentTransactionMock = new Mock<IPaymentTransactionService>();
+
+ _handler = new CaptureCommandHandler(_paymentServiceMock.Object, _paymentTransactionMock.Object, _mediatorMock.Object, _orderServiceMock.Object, _loggerMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new CaptureCommand() { PaymentTransaction = new PaymentTransaction() };
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CanCaptureQuery>(), default))
+ .Returns(Task.FromResult(true));
+
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+
+ _paymentServiceMock.Verify(c => c.Capture(It.IsAny<PaymentTransaction>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/DeleteOrderCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/DeleteOrderCommandHandlerTests.cs
new file mode 100644
index 000000000..668af9c87
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/DeleteOrderCommandHandlerTests.cs
@@ -0,0 +1,57 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Catalog.Discounts;
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Shipping;
+using Grand.Domain.Orders;
+using Grand.Domain.Shipping;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class DeleteOrderCommandHandlerTests
+ {
+ private DeleteOrderCommandHandler _handler;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IShipmentService> _shipmentServiceMock;
+ private Mock<IProductService> _productServiceMock;
+ private Mock<IInventoryManageService> _inventoryManageServiceMock;
+ private Mock<IProductReservationService> _productReservationServiceMock;
+ private Mock<IAuctionService> _auctionServiceMock;
+ private Mock<IDiscountService> _discountServiceMock;
+ private OrderSettings _orderSettings;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _shipmentServiceMock = new Mock<IShipmentService>();
+ _productServiceMock = new Mock<IProductService>();
+ _inventoryManageServiceMock = new Mock<IInventoryManageService>();
+ _productReservationServiceMock = new Mock<IProductReservationService>();
+ _auctionServiceMock = new Mock<IAuctionService>();
+ _discountServiceMock = new Mock<IDiscountService>();
+
+ _orderSettings = new OrderSettings();
+
+ _handler = new DeleteOrderCommandHandler(_mediatorMock.Object, _orderServiceMock.Object, _shipmentServiceMock.Object, _productServiceMock.Object, _inventoryManageServiceMock.Object, _productReservationServiceMock.Object,
+ _auctionServiceMock.Object, _discountServiceMock.Object, _orderSettings);
+ }
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new DeleteOrderCommand() { Order = new Order() { OrderStatusId = (int)OrderStatusSystem.Pending } };
+ _shipmentServiceMock.Setup(c => c.GetShipmentsByOrder(It.IsAny<string>())).ReturnsAsync(new List<Shipment>());
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+ //Assert
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/DeleteOrderItemCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/DeleteOrderItemCommandHandlerTests.cs
new file mode 100644
index 000000000..7c20aa20d
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/DeleteOrderItemCommandHandlerTests.cs
@@ -0,0 +1,53 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Grand.Business.Core.Interfaces.Checkout.GiftVouchers;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Shipping;
+using Grand.Domain.Catalog;
+using Grand.Domain.Orders;
+using Grand.Domain.Shipping;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class DeleteOrderItemCommandHandlerTests
+ {
+ private DeleteOrderItemCommandHandler _handler;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IShipmentService> _shipmentServiceMock;
+ private Mock<IProductService> _productServiceMock;
+ private Mock<IInventoryManageService> _inventoryManageServiceMock;
+ private Mock<IGiftVoucherService> _giftVoucherServiceMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _shipmentServiceMock = new Mock<IShipmentService>();
+ _productServiceMock = new Mock<IProductService>();
+ _inventoryManageServiceMock = new Mock<IInventoryManageService>();
+ _giftVoucherServiceMock = new Mock<IGiftVoucherService>();
+
+ _handler = new DeleteOrderItemCommandHandler(_mediatorMock.Object, _orderServiceMock.Object, _shipmentServiceMock.Object, _productServiceMock.Object,
+ _giftVoucherServiceMock.Object, _inventoryManageServiceMock.Object);
+ }
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new DeleteOrderItemCommand() { Order = new Order() { OrderStatusId = (int)OrderStatusSystem.Pending }, OrderItem = new OrderItem() { Quantity = 1, OpenQty = 1, Status = OrderItemStatus.Open } };
+ _shipmentServiceMock.Setup(c => c.GetShipmentsByOrder(It.IsAny<string>())).ReturnsAsync(new List<Shipment>());
+ _giftVoucherServiceMock.Setup(c => c.GetGiftVouchersByPurchasedWithOrderItemId(It.IsAny<string>())).ReturnsAsync(new List<GiftVoucher>());
+ _productServiceMock.Setup(a => a.GetProductById(It.IsAny<string>(), false)).Returns(() => Task.FromResult(new Product() { Id = "2", Published = true, Price = 10 }));
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+ //Assert
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/InsertOrderItemCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/InsertOrderItemCommandHandlerTests.cs
new file mode 100644
index 000000000..5720b8147
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/InsertOrderItemCommandHandlerTests.cs
@@ -0,0 +1,51 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Grand.Business.Core.Interfaces.Checkout.GiftVouchers;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Shipping;
+using Grand.Domain.Catalog;
+using Grand.Domain.Orders;
+using Grand.Domain.Shipping;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class InsertOrderItemCommandHandlerTests
+ {
+ private InsertOrderItemCommandHandler _handler;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IShipmentService> _shipmentServiceMock;
+ private Mock<IProductService> _productServiceMock;
+ private Mock<IInventoryManageService> _inventoryManageServiceMock;
+ private Mock<IGiftVoucherService> _giftVoucherServiceMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _shipmentServiceMock = new Mock<IShipmentService>();
+ _productServiceMock = new Mock<IProductService>();
+ _inventoryManageServiceMock = new Mock<IInventoryManageService>();
+ _giftVoucherServiceMock = new Mock<IGiftVoucherService>();
+
+ _handler = new InsertOrderItemCommandHandler(_mediatorMock.Object, _orderServiceMock.Object,
+ _giftVoucherServiceMock.Object, _inventoryManageServiceMock.Object);
+ }
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new InsertOrderItemCommand() { Order = new Order() { OrderStatusId = (int)OrderStatusSystem.Pending }, OrderItem = new OrderItem() { Quantity = 1, OpenQty = 1, Status = OrderItemStatus.Open }, Product = new Product() };
+ _giftVoucherServiceMock.Setup(c => c.GetGiftVouchersByPurchasedWithOrderItemId(It.IsAny<string>())).ReturnsAsync(new List<GiftVoucher>());
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+ //Assert
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/MarkAsAuthorizedCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/MarkAsAuthorizedCommandHandlerTests.cs
new file mode 100644
index 000000000..120bbf7a7
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/MarkAsAuthorizedCommandHandlerTests.cs
@@ -0,0 +1,49 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Grand.Business.Checkout.Commands.Handlers.Orders;
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Domain.Orders;
+using Grand.Domain.Payments;
+using MediatR;
+using Moq;
+using Grand.Business.Core.Interfaces.Checkout.Payments;
+using Grand.Business.Core.Interfaces.Common.Logging;
+using Grand.Business.Core.Queries.Checkout.Orders;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class MarkAsAuthorizedCommandHandlerTests
+ {
+ private MarkAsAuthorizedCommandHandler _handler;
+
+ private Mock<IPaymentTransactionService> _paymentTransactionMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IMediator> _mediatorMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _paymentTransactionMock = new Mock<IPaymentTransactionService>();
+
+ _handler = new MarkAsAuthorizedCommandHandler(_orderServiceMock.Object, _paymentTransactionMock.Object, _mediatorMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new MarkAsAuthorizedCommand() { PaymentTransaction = new PaymentTransaction() };
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CanCaptureQuery>(), default))
+ .Returns(Task.FromResult(true));
+ _orderServiceMock.Setup(x => x.GetOrderByGuid(It.IsAny<Guid>())).Returns(Task.FromResult(new Order()));
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ _paymentTransactionMock.Verify(c => c.UpdatePaymentTransaction(It.IsAny<PaymentTransaction>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/MarkAsPaidCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/MarkAsPaidCommandHandlerTests.cs
new file mode 100644
index 000000000..2268ae15f
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/MarkAsPaidCommandHandlerTests.cs
@@ -0,0 +1,50 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Payments;
+using Grand.Business.Core.Queries.Checkout.Orders;
+using Grand.Domain.Orders;
+using Grand.Domain.Payments;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class MarkAsPaidCommandHandlerTests
+ {
+ private MarkAsPaidCommandHandler _handler;
+
+ private Mock<IPaymentTransactionService> _paymentTransactionMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IMediator> _mediatorMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _paymentTransactionMock = new Mock<IPaymentTransactionService>();
+
+ _handler = new MarkAsPaidCommandHandler(_mediatorMock.Object, _orderServiceMock.Object, _paymentTransactionMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new MarkAsPaidCommand() { PaymentTransaction = new PaymentTransaction() };
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CanCaptureQuery>(), default))
+ .Returns(Task.FromResult(true));
+ _orderServiceMock.Setup(x => x.GetOrderByGuid(It.IsAny<Guid>())).Returns(Task.FromResult(new Order()));
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CanMarkPaymentTransactionAsPaidQuery>(), default))
+ .Returns(Task.FromResult(true));
+
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ _paymentTransactionMock.Verify(c => c.UpdatePaymentTransaction(It.IsAny<PaymentTransaction>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/MaxOrderNumberCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/MaxOrderNumberCommandHandlerTests.cs
new file mode 100644
index 000000000..449a70981
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/MaxOrderNumberCommandHandlerTests.cs
@@ -0,0 +1,30 @@
+using Grand.Data.Tests.MongoDb;
+using Grand.Domain.Data;
+using Grand.Domain.Orders;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class MaxOrderNumberCommandHandlerTests
+ {
+ private MaxOrderNumberCommandHandler _handler;
+ private IRepository<Order> _repository;
+ [TestInitialize]
+ public void Init()
+ {
+ _repository = new MongoDBRepositoryTest<Order>();
+
+ _handler = new MaxOrderNumberCommandHandler(_repository);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Act
+ var result = await _handler.Handle(new Core.Commands.Checkout.Orders.MaxOrderNumberCommand() { OrderNumber = 10 }, CancellationToken.None);
+ //Assert
+ Assert.AreEqual(10, result);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/OrderStatusCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/OrderStatusCommandHandlerTests.cs
new file mode 100644
index 000000000..d4841c82e
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/OrderStatusCommandHandlerTests.cs
@@ -0,0 +1,54 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Catalog.Discounts;
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Shipping;
+using Grand.Business.Core.Interfaces.Common.Pdf;
+using Grand.Business.Core.Interfaces.Customers;
+using Grand.Business.Core.Interfaces.Messages;
+using Grand.Domain.Orders;
+using Grand.Domain.Shipping;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class OrderStatusCommandHandlerTests
+ {
+ private OrderStatusCommandHandler _handler;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<ICustomerService> _customerServiceMock;
+ private Mock<IPdfService> _pdfServiceMock;
+ private Mock<IMessageProviderService> _messageProviderServiceMock;
+ private Mock<IVendorService> _vendorServiceMock;
+ private LoyaltyPointsSettings _loyaltyPointsSettings;
+ private OrderSettings _orderSettings;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _customerServiceMock = new Mock<ICustomerService>();
+ _pdfServiceMock = new Mock<IPdfService>();
+ _messageProviderServiceMock = new Mock<IMessageProviderService>();
+ _vendorServiceMock = new Mock<IVendorService>();
+ _loyaltyPointsSettings = new LoyaltyPointsSettings();
+ _orderSettings = new OrderSettings();
+
+ _handler = new OrderStatusCommandHandler(_orderServiceMock.Object, _customerServiceMock.Object, _pdfServiceMock.Object, _messageProviderServiceMock.Object, _vendorServiceMock.Object, _mediatorMock.Object, _orderSettings, _loyaltyPointsSettings);
+ }
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new SetOrderStatusCommand() { Order = new Order() { OrderStatusId = (int)OrderStatusSystem.Pending }, Os = OrderStatusSystem.Complete };
+ //Act
+ await _handler.Handle(command, CancellationToken.None);
+ //Assert
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PartiallyPaidOfflineCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PartiallyPaidOfflineCommandHandlerTests.cs
new file mode 100644
index 000000000..4d4307f69
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PartiallyPaidOfflineCommandHandlerTests.cs
@@ -0,0 +1,49 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Grand.Business.Checkout.Commands.Handlers.Orders;
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Domain.Orders;
+using Grand.Domain.Payments;
+using MediatR;
+using Moq;
+using Grand.Business.Core.Interfaces.Checkout.Payments;
+using Grand.Business.Core.Interfaces.Common.Logging;
+using Grand.Business.Core.Queries.Checkout.Orders;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class PartiallyPaidOfflineCommandHandlerTests
+ {
+ private PartiallyPaidOfflineCommandHandler _handler;
+
+ private Mock<IPaymentTransactionService> _paymentTransactionMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IMediator> _mediatorMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _paymentTransactionMock = new Mock<IPaymentTransactionService>();
+
+ _handler = new PartiallyPaidOfflineCommandHandler(_orderServiceMock.Object, _paymentTransactionMock.Object, _mediatorMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new PartiallyPaidOfflineCommand() { PaymentTransaction = new PaymentTransaction() };
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CanPartiallyPaidOfflineQuery>(), default))
+ .Returns(Task.FromResult(true));
+ _orderServiceMock.Setup(x => x.GetOrderByGuid(It.IsAny<Guid>())).Returns(Task.FromResult(new Order()));
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ _paymentTransactionMock.Verify(c => c.UpdatePaymentTransaction(It.IsAny<PaymentTransaction>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PartiallyRefundCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PartiallyRefundCommandHandlerTests.cs
new file mode 100644
index 000000000..66e9a9cc3
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PartiallyRefundCommandHandlerTests.cs
@@ -0,0 +1,57 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Payments;
+using Grand.Business.Core.Interfaces.Common.Logging;
+using Grand.Business.Core.Interfaces.Messages;
+using Grand.Business.Core.Queries.Checkout.Orders;
+using Grand.Business.Core.Utilities.Checkout;
+using Grand.Domain.Orders;
+using Grand.Domain.Payments;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class PartiallyRefundCommandHandlerTests
+ {
+ private PartiallyRefundCommandHandler _handler;
+ private Mock<IPaymentService> _paymentServiceMock;
+ private Mock<IPaymentTransactionService> _paymentTransactionMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IMessageProviderService> _messageProviderServiceMock;
+ private Mock<ILogger> _loggerMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _paymentTransactionMock = new Mock<IPaymentTransactionService>();
+ _messageProviderServiceMock = new Mock<IMessageProviderService>();
+ _paymentServiceMock = new Mock<IPaymentService>();
+ _loggerMock = new Mock<ILogger>();
+
+ _handler = new PartiallyRefundCommandHandler(_paymentServiceMock.Object, _paymentTransactionMock.Object, _mediatorMock.Object, _messageProviderServiceMock.Object, _loggerMock.Object, _orderServiceMock.Object, new Domain.Localization.LanguageSettings());
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new PartiallyRefundCommand() { PaymentTransaction = new PaymentTransaction() };
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CanPartiallyRefundQuery>(), default))
+ .Returns(Task.FromResult(true));
+ _orderServiceMock.Setup(x => x.GetOrderByGuid(It.IsAny<Guid>())).Returns(Task.FromResult(new Order()));
+ _paymentServiceMock.Setup(x => x.Refund(It.IsAny<RefundPaymentRequest>())).Returns(Task.FromResult(new RefundPaymentResult() { NewTransactionStatus = TransactionStatus.Refunded }));
+ _paymentTransactionMock.Setup(x => x.GetById(It.IsAny<string>())).Returns(Task.FromResult(new PaymentTransaction()));
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+ //Assert
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ _paymentTransactionMock.Verify(c => c.UpdatePaymentTransaction(It.IsAny<PaymentTransaction>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PartiallyRefundOfflineCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PartiallyRefundOfflineCommandHandlerTests.cs
new file mode 100644
index 000000000..ddd794959
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PartiallyRefundOfflineCommandHandlerTests.cs
@@ -0,0 +1,50 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Payments;
+using Grand.Business.Core.Interfaces.Messages;
+using Grand.Business.Core.Queries.Checkout.Orders;
+using Grand.Domain.Orders;
+using Grand.Domain.Payments;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class PartiallyRefundOfflineCommandHandlerTests
+ {
+ private PartiallyRefundOfflineCommandHandler _handler;
+ private Mock<IPaymentTransactionService> _paymentTransactionMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IMessageProviderService> _messageProviderServiceMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _paymentTransactionMock = new Mock<IPaymentTransactionService>();
+ _messageProviderServiceMock = new Mock<IMessageProviderService>();
+
+ _handler = new PartiallyRefundOfflineCommandHandler(_orderServiceMock.Object, _paymentTransactionMock.Object, _mediatorMock.Object, _messageProviderServiceMock.Object, new Domain.Localization.LanguageSettings());
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new PartiallyRefundOfflineCommand() { PaymentTransaction = new PaymentTransaction() };
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CanPartiallyRefundOfflineQuery>(), default))
+ .Returns(Task.FromResult(true));
+ _orderServiceMock.Setup(x => x.GetOrderByGuid(It.IsAny<Guid>())).Returns(Task.FromResult(new Order()));
+ _paymentTransactionMock.Setup(x => x.GetById(It.IsAny<string>())).Returns(Task.FromResult(new PaymentTransaction()));
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+ //Assert
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ _paymentTransactionMock.Verify(c => c.UpdatePaymentTransaction(It.IsAny<PaymentTransaction>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PrepareOrderCodeCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PrepareOrderCodeCommandHandlerTests.cs
new file mode 100644
index 000000000..e86b7e62c
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/PrepareOrderCodeCommandHandlerTests.cs
@@ -0,0 +1,26 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class PrepareOrderCodeCommandHandlerTests
+ {
+ private PrepareOrderCodeCommandHandler _handler;
+ const int LengthCode = 6;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _handler = new PrepareOrderCodeCommandHandler(new Domain.Orders.OrderSettings() { LengthCode = LengthCode });
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Act
+ var result = await _handler.Handle(new Core.Commands.Checkout.Orders.PrepareOrderCodeCommand(), CancellationToken.None);
+ //Assert
+ Assert.AreEqual(LengthCode, result.Length);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ReduceLoyaltyPointsCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ReduceLoyaltyPointsCommandHandlerTests.cs
new file mode 100644
index 000000000..6c06d4f86
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ReduceLoyaltyPointsCommandHandlerTests.cs
@@ -0,0 +1,60 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Common.Directory;
+using Grand.Business.Core.Interfaces.Common.Localization;
+using Grand.Business.Core.Interfaces.Customers;
+using MediatR;
+using Moq;
+using Grand.Domain.Customers;
+using Grand.Domain.Directory;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class ReduceLoyaltyPointsCommandHandlerTests
+ {
+ private ReduceLoyaltyPointsCommandHandler _handler;
+ private Mock<ICustomerService> _customerServiceMock;
+ private Mock<ILoyaltyPointsService> _loyaltyPointsServiceMock;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<ITranslationService> _translationServiceMock;
+ private Mock<ICurrencyService> _currencyServiceMock;
+
+
+ [TestInitialize]
+ public void Init()
+ {
+ _customerServiceMock = new Mock<ICustomerService>();
+ _loyaltyPointsServiceMock = new Mock<ILoyaltyPointsService>();
+ _mediatorMock = new Mock<IMediator>();
+ _currencyServiceMock = new Mock<ICurrencyService>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _translationServiceMock = new Mock<ITranslationService>();
+
+ _handler = new ReduceLoyaltyPointsCommandHandler(_customerServiceMock.Object, _loyaltyPointsServiceMock.Object, _mediatorMock.Object, _orderServiceMock.Object, _translationServiceMock.Object, _currencyServiceMock.Object);
+ }
+
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new ReduceLoyaltyPointsCommand();
+ command.Order = new Domain.Orders.Order() { StoreId = "", OrderNumber = 1, CalcLoyaltyPoints = 100 };
+ var expectedCustomer = new Customer() { Username = "John", Active = true };
+ _customerServiceMock.Setup(c => c.GetCustomerById(It.IsAny<string>())).Returns(() => Task.FromResult(expectedCustomer));
+ _currencyServiceMock.Setup(c => c.GetCurrencyByCode(It.IsAny<string>())).Returns(() => Task.FromResult(new Domain.Directory.Currency()));
+ _currencyServiceMock.Setup(c => c.ConvertToPrimaryStoreCurrency(100, It.IsAny<Currency>())).Returns(() => Task.FromResult((double)100));
+ _translationServiceMock.Setup(x => x.GetResource(It.IsAny<string>())).Returns("Name");
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CalculateLoyaltyPointsCommand>(), default)).Returns(Task.FromResult(100));
+
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+
+ //Assert
+ _loyaltyPointsServiceMock.Verify(c => c.AddLoyaltyPointsHistory(It.IsAny<string>(), It.Is<int>(g => g <0), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<double>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/RefundCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/RefundCommandHandlerTests.cs
new file mode 100644
index 000000000..593b30636
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/RefundCommandHandlerTests.cs
@@ -0,0 +1,57 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Payments;
+using Grand.Business.Core.Interfaces.Common.Logging;
+using Grand.Business.Core.Interfaces.Messages;
+using Grand.Business.Core.Queries.Checkout.Orders;
+using Grand.Business.Core.Utilities.Checkout;
+using Grand.Domain.Orders;
+using Grand.Domain.Payments;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class RefundCommandHandlerTests
+ {
+ private RefundCommandHandler _handler;
+ private Mock<IPaymentService> _paymentServiceMock;
+ private Mock<IPaymentTransactionService> _paymentTransactionMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IMessageProviderService> _messageProviderServiceMock;
+ private Mock<ILogger> _loggerMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _paymentTransactionMock = new Mock<IPaymentTransactionService>();
+ _messageProviderServiceMock = new Mock<IMessageProviderService>();
+ _paymentServiceMock = new Mock<IPaymentService>();
+ _loggerMock = new Mock<ILogger>();
+
+ _handler = new RefundCommandHandler(_mediatorMock.Object, _paymentServiceMock.Object, _paymentTransactionMock.Object, _orderServiceMock.Object, _messageProviderServiceMock.Object, _loggerMock.Object, new Domain.Localization.LanguageSettings());
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new RefundCommand() { PaymentTransaction = new PaymentTransaction() };
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CanPartiallyRefundQuery>(), default))
+ .Returns(Task.FromResult(true));
+ _orderServiceMock.Setup(x => x.GetOrderByGuid(It.IsAny<Guid>())).Returns(Task.FromResult(new Order()));
+ _paymentServiceMock.Setup(x => x.Refund(It.IsAny<RefundPaymentRequest>())).Returns(Task.FromResult(new RefundPaymentResult() { NewTransactionStatus = TransactionStatus.Refunded }));
+ _paymentTransactionMock.Setup(x => x.GetById(It.IsAny<string>())).Returns(Task.FromResult(new PaymentTransaction()));
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+ //Assert
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ _paymentTransactionMock.Verify(c => c.UpdatePaymentTransaction(It.IsAny<PaymentTransaction>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ReturnBackRedeemedLoyaltyPointsCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ReturnBackRedeemedLoyaltyPointsCommandHandlerTests.cs
new file mode 100644
index 000000000..31cfe4539
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ReturnBackRedeemedLoyaltyPointsCommandHandlerTests.cs
@@ -0,0 +1,43 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Grand.Business.Checkout.Commands.Handlers.Orders;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Grand.Business.Core.Interfaces.Common.Localization;
+using Moq;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class ReturnBackRedeemedLoyaltyPointsCommandHandlerTests
+ {
+ private ReturnBackRedeemedLoyaltyPointsCommandHandler _handler;
+ private Mock<ILoyaltyPointsService> _loyaltyPointsServiceMock;
+ private Mock<ITranslationService> _translationServiceMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _loyaltyPointsServiceMock = new Mock<ILoyaltyPointsService>();
+ _translationServiceMock = new Mock<ITranslationService>();
+ _handler = new ReturnBackRedeemedLoyaltyPointsCommandHandler(_loyaltyPointsServiceMock.Object, _translationServiceMock.Object);
+ }
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new Core.Commands.Checkout.Orders.ReturnBackRedeemedLoyaltyPointsCommand();
+ command.Order = new Domain.Orders.Order() { RedeemedLoyaltyPoints = 10 };
+ _translationServiceMock.Setup(x => x.GetResource(It.IsAny<string>())).Returns("Name");
+ //Act
+ await _handler.Handle(command, CancellationToken.None);
+
+ _loyaltyPointsServiceMock.Verify(c => c.AddLoyaltyPointsHistory(It.IsAny<string>(), It.Is<int>(g => g < 0), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<double>()), Times.Once);
+
+
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/UpdateOrderItemCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/UpdateOrderItemCommandHandlerTests.cs
new file mode 100644
index 000000000..7eacb6511
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/UpdateOrderItemCommandHandlerTests.cs
@@ -0,0 +1,58 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Grand.Business.Core.Interfaces.Checkout.GiftVouchers;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Shipping;
+using Grand.Domain.Catalog;
+using Grand.Domain.Orders;
+using Grand.Domain.Shipping;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class UpdateOrderItemCommandHandlerTests
+ {
+ private UpdateOrderItemCommandHandler _handler;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IShipmentService> _shipmentServiceMock;
+ private Mock<IProductService> _productServiceMock;
+ private Mock<IInventoryManageService> _inventoryManageServiceMock;
+ private Mock<IGiftVoucherService> _giftVoucherServiceMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _shipmentServiceMock = new Mock<IShipmentService>();
+ _productServiceMock = new Mock<IProductService>();
+ _inventoryManageServiceMock = new Mock<IInventoryManageService>();
+ _giftVoucherServiceMock = new Mock<IGiftVoucherService>();
+
+ _handler = new UpdateOrderItemCommandHandler(_mediatorMock.Object, _orderServiceMock.Object, _shipmentServiceMock.Object, _productServiceMock.Object,
+ _inventoryManageServiceMock.Object);
+ }
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var order = new Order() { OrderStatusId = (int)OrderStatusSystem.Pending };
+ var orderItem = new OrderItem();
+ order.OrderItems.Add(orderItem);
+
+ var command = new UpdateOrderItemCommand() { Order = order, OrderItem = orderItem };
+ _orderServiceMock.Setup(x => x.GetOrderById(It.IsAny<string>())).Returns(Task.FromResult(order));
+ _shipmentServiceMock.Setup(c => c.GetShipmentsByOrder(It.IsAny<string>())).ReturnsAsync(new List<Shipment>());
+ _giftVoucherServiceMock.Setup(c => c.GetGiftVouchersByPurchasedWithOrderItemId(It.IsAny<string>())).ReturnsAsync(new List<GiftVoucher>());
+ _productServiceMock.Setup(a => a.GetProductById(It.IsAny<string>(), false)).Returns(() => Task.FromResult(new Product() { Id = "2", Published = true, Price = 10 }));
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+ //Assert
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ValidateMinShoppingCartSubtotalAmountCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ValidateMinShoppingCartSubtotalAmountCommandHandlerTests.cs
new file mode 100644
index 000000000..123812032
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ValidateMinShoppingCartSubtotalAmountCommandHandlerTests.cs
@@ -0,0 +1,39 @@
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Utilities.Catalog;
+using Grand.Domain.Orders;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class ValidateMinShoppingCartSubtotalAmountCommandHandlerTests
+ {
+ private ValidateMinShoppingCartSubtotalAmountCommandHandler _handler;
+ private Mock<IOrderCalculationService> _orderTotalCalculationServiceMock;
+ private OrderSettings _orderSettings;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _orderTotalCalculationServiceMock = new Mock<IOrderCalculationService>();
+ _orderSettings = new OrderSettings() { MinOrderSubtotalAmount = 10};
+ _handler = new ValidateMinShoppingCartSubtotalAmountCommandHandler(_orderTotalCalculationServiceMock.Object, _orderSettings);
+ }
+
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ var command = new Core.Commands.Checkout.Orders.ValidateMinShoppingCartSubtotalAmountCommand();
+ command.Customer = new Domain.Customers.Customer();
+ command.Cart = new List<ShoppingCartItem>() { new ShoppingCartItem() };
+
+ _orderTotalCalculationServiceMock.Setup(x => x.GetShoppingCartSubTotal(It.IsAny<IList<ShoppingCartItem>>(), false)).Returns(() => Task.FromResult<(double discountAmount, List<ApplyDiscount> appliedDiscounts, double subTotalWithoutDiscount, double subTotalWithDiscount, SortedDictionary<double, double> taxRates)>((20,null, 100,100,null)));
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+ //Assert
+ Assert.IsTrue(result);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/VoidCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/VoidCommandHandlerTests.cs
new file mode 100644
index 000000000..1ad27af97
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/VoidCommandHandlerTests.cs
@@ -0,0 +1,59 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Payments;
+using Grand.Business.Core.Interfaces.Common.Logging;
+using Grand.Business.Core.Interfaces.Messages;
+using Grand.Business.Core.Queries.Checkout.Orders;
+using Grand.Business.Core.Utilities.Checkout;
+using Grand.Domain.Orders;
+using Grand.Domain.Payments;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class VoidCommandHandlerTests
+ {
+ private VoidCommandHandler _handler;
+ private Mock<IPaymentService> _paymentServiceMock;
+ private Mock<IPaymentTransactionService> _paymentTransactionMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IMessageProviderService> _messageProviderServiceMock;
+ private Mock<ILogger> _loggerMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _paymentTransactionMock = new Mock<IPaymentTransactionService>();
+ _messageProviderServiceMock = new Mock<IMessageProviderService>();
+ _paymentServiceMock = new Mock<IPaymentService>();
+ _loggerMock = new Mock<ILogger>();
+
+ _handler = new VoidCommandHandler(
+ _orderServiceMock.Object,
+ _mediatorMock.Object, _paymentServiceMock.Object, _paymentTransactionMock.Object, _loggerMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new VoidCommand() { PaymentTransaction = new PaymentTransaction() };
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CanVoidQuery>(), default))
+ .Returns(Task.FromResult(true));
+ _orderServiceMock.Setup(x => x.GetOrderByGuid(It.IsAny<Guid>())).Returns(Task.FromResult(new Order()));
+ _paymentServiceMock.Setup(x => x.Void(It.IsAny<PaymentTransaction>())).Returns(Task.FromResult(new VoidPaymentResult() { NewTransactionStatus = TransactionStatus.Voided }));
+ _paymentTransactionMock.Setup(x => x.GetById(It.IsAny<string>())).Returns(Task.FromResult(new PaymentTransaction()));
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+ //Assert
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ _paymentTransactionMock.Verify(c => c.UpdatePaymentTransaction(It.IsAny<PaymentTransaction>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/VoidOfflineCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/VoidOfflineCommandHandlerTests.cs
new file mode 100644
index 000000000..e9171daaa
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/VoidOfflineCommandHandlerTests.cs
@@ -0,0 +1,53 @@
+using Grand.Business.Core.Commands.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Payments;
+using Grand.Business.Core.Queries.Checkout.Orders;
+using Grand.Business.Core.Utilities.Checkout;
+using Grand.Domain.Orders;
+using Grand.Domain.Payments;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Commands.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class VoidOfflineCommandHandlerTests
+ {
+ private VoidOfflineCommandHandler _handler;
+ private Mock<IPaymentService> _paymentServiceMock;
+ private Mock<IPaymentTransactionService> _paymentTransactionMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IMediator> _mediatorMock;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _paymentTransactionMock = new Mock<IPaymentTransactionService>();
+ _paymentServiceMock = new Mock<IPaymentService>();
+
+ _handler = new VoidOfflineCommandHandler(
+ _orderServiceMock.Object, _paymentTransactionMock.Object,
+ _mediatorMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var command = new VoidOfflineCommand() { PaymentTransaction = new PaymentTransaction() };
+ _mediatorMock.Setup(x => x.Send(It.IsAny<CanVoidOfflineQuery>(), default))
+ .Returns(Task.FromResult(true));
+ _orderServiceMock.Setup(x => x.GetOrderByGuid(It.IsAny<Guid>())).Returns(Task.FromResult(new Order()));
+ _paymentServiceMock.Setup(x => x.Void(It.IsAny<PaymentTransaction>())).Returns(Task.FromResult(new VoidPaymentResult() { NewTransactionStatus = TransactionStatus.Voided }));
+ _paymentTransactionMock.Setup(x => x.GetById(It.IsAny<string>())).Returns(Task.FromResult(new PaymentTransaction()));
+ //Act
+ var result = await _handler.Handle(command, CancellationToken.None);
+ //Assert
+ _orderServiceMock.Verify(c => c.UpdateOrder(It.IsAny<Order>()), Times.Once);
+ _paymentTransactionMock.Verify(c => c.UpdatePaymentTransaction(It.IsAny<PaymentTransaction>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file