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

support416c1ad4f9e7
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/ActivatedValueForPurchasedGiftVouchersCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ActivatedValueForPurchasedGiftVouchersCommandHandlerTests.cs
similarity index 98%
rename from src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/ActivatedValueForPurchasedGiftVouchersCommandHandlerTests.cs
rename to src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ActivatedValueForPurchasedGiftVouchersCommandHandlerTests.cs
index 56293156b..952f949d1 100644
--- a/src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/ActivatedValueForPurchasedGiftVouchersCommandHandlerTests.cs
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/ActivatedValueForPurchasedGiftVouchersCommandHandlerTests.cs
@@ -9,7 +9,7 @@ using Grand.Domain.Orders;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
-namespace Grand.Business.Checkout.Tests.Commands.Orders
+namespace Grand.Business.Checkout.Tests.Commands.Handlers.Orders
{
[TestClass]
public class ActivatedValueForPurchasedGiftVouchersCommandHandlerTests
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/CalculateLoyaltyPointsCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CalculateLoyaltyPointsCommandHandlerTests.cs
similarity index 97%
rename from src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/CalculateLoyaltyPointsCommandHandlerTests.cs
rename to src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CalculateLoyaltyPointsCommandHandlerTests.cs
index f51fa64ff..68dacfa8f 100644
--- a/src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/CalculateLoyaltyPointsCommandHandlerTests.cs
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CalculateLoyaltyPointsCommandHandlerTests.cs
@@ -3,7 +3,7 @@ using Grand.Business.Core.Commands.Checkout.Orders;
using Grand.Domain.Orders;
using Microsoft.VisualStudio.TestTools.UnitTesting;
-namespace Grand.Business.Checkout.Tests.Commands.Orders
+namespace Grand.Business.Checkout.Tests.Commands.Handlers.Orders
{
[TestClass]
public class CalculateLoyaltyPointsCommandHandlerTests
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/CancelOrderCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CancelOrderCommandHandlerTests.cs
similarity index 95%
rename from src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/CancelOrderCommandHandlerTests.cs
rename to src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CancelOrderCommandHandlerTests.cs
index d08eb8122..fe7067c9f 100644
--- a/src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/CancelOrderCommandHandlerTests.cs
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CancelOrderCommandHandlerTests.cs
@@ -12,7 +12,7 @@ using MediatR;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
-namespace Grand.Business.Checkout.Tests.Commands.Orders
+namespace Grand.Business.Checkout.Tests.Commands.Handlers.Orders
{
[TestClass]
public class CancelOrderCommandHandlerTests
@@ -75,7 +75,7 @@ namespace Grand.Business.Checkout.Tests.Commands.Orders
_productReservationMock.Verify(c => c.CancelReservationsByOrderId("id"), Times.Once);
_auctionMock.Verify(c => c.CancelBidByOrder("id"), Times.Once);
_discountServiceMock.Verify(c => c.CancelDiscount("id"), Times.Once);
- _mediatorMock.Verify(c => c.Publish<OrderCancelledEvent>(It.IsAny<OrderCancelledEvent>(), default));
+ _mediatorMock.Verify(c => c.Publish(It.IsAny<OrderCancelledEvent>(), default));
}
}
}
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/CheckOrderStatusCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CheckOrderStatusCommandHandlerTests.cs
similarity index 91%
rename from src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/CheckOrderStatusCommandHandlerTests.cs
rename to src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CheckOrderStatusCommandHandlerTests.cs
index 8a1ab2e7c..d581a5da5 100644
--- a/src/Tests/Grand.Business.Checkout.Tests/Commands/Orders/CheckOrderStatusCommandHandlerTests.cs
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Orders/CheckOrderStatusCommandHandlerTests.cs
@@ -7,7 +7,7 @@ using MediatR;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
-namespace Grand.Business.Checkout.Tests.Commands.Orders
+namespace Grand.Business.Checkout.Tests.Commands.Handlers.Orders
{
[TestClass]
public class CheckOrderStatusCommandHandlerTests
@@ -29,7 +29,7 @@ namespace Grand.Business.Checkout.Tests.Commands.Orders
[TestMethod]
public async Task Handle_InvokeExpectedMethods()
{
- CheckOrderStatusCommand request = new CheckOrderStatusCommand();
+ var request = new CheckOrderStatusCommand();
request.Order = new Order();
request.Order.PaymentStatusId = PaymentStatus.Paid;
request.Order.PaidDateUtc = null;
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Shipping/DeliveryCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Shipping/DeliveryCommandHandlerTests.cs
new file mode 100644
index 000000000..c8f0a71ae
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Shipping/DeliveryCommandHandlerTests.cs
@@ -0,0 +1,44 @@
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Shipping;
+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.Shipping.Tests
+{
+ [TestClass()]
+ public class DeliveryCommandHandlerTests
+ {
+ private DeliveryCommandHandler _deliveryCommandHandler;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IShipmentService> _shipmentServiceMock;
+ private Mock<IMessageProviderService> _messageProviderServiceMock;
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _shipmentServiceMock = new Mock<IShipmentService>();
+ _messageProviderServiceMock = new Mock<IMessageProviderService>();
+
+ _deliveryCommandHandler = new DeliveryCommandHandler(_mediatorMock.Object, _orderServiceMock.Object, _shipmentServiceMock.Object, _messageProviderServiceMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ _orderServiceMock.Setup(x => x.GetOrderById(It.IsAny<string>())).Returns(Task.FromResult(new Order()));
+ _shipmentServiceMock.Setup(x => x.GetShipmentsByOrder(It.IsAny<string>())).Returns(Task.FromResult((IList<Shipment>)new List<Shipment>()));
+ var deliveryCommand = new Core.Commands.Checkout.Shipping.DeliveryCommand() { NotifyCustomer = true, Shipment = new Domain.Shipping.Shipment() { ShippedDateUtc = DateTime.Now } };
+ //Act
+ var result = await _deliveryCommandHandler.Handle(deliveryCommand, CancellationToken.None);
+ //Assert
+ _shipmentServiceMock.Verify(c => c.UpdateShipment(It.IsAny<Shipment>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Shipping/ShipCommandHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Shipping/ShipCommandHandlerTests.cs
new file mode 100644
index 000000000..64d8f60fd
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Commands/Handlers/Shipping/ShipCommandHandlerTests.cs
@@ -0,0 +1,44 @@
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Shipping;
+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.Shipping.Tests
+{
+ [TestClass()]
+ public class ShipCommandHandlerTests
+ {
+ private ShipCommandHandler _shipCommandHandler;
+ private Mock<IMediator> _mediatorMock;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IShipmentService> _shipmentServiceMock;
+ private Mock<IMessageProviderService> _messageProviderServiceMock;
+ [TestInitialize]
+ public void Init()
+ {
+ _mediatorMock = new Mock<IMediator>();
+ _orderServiceMock = new Mock<IOrderService>();
+ _shipmentServiceMock = new Mock<IShipmentService>();
+ _messageProviderServiceMock = new Mock<IMessageProviderService>();
+
+ _shipCommandHandler = new ShipCommandHandler(_mediatorMock.Object, _orderServiceMock.Object, _shipmentServiceMock.Object, _messageProviderServiceMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ _orderServiceMock.Setup(x => x.GetOrderById(It.IsAny<string>())).Returns(Task.FromResult(new Order()));
+ _shipmentServiceMock.Setup(x => x.GetShipmentsByOrder(It.IsAny<string>())).Returns(Task.FromResult((IList<Shipment>)new List<Shipment>()));
+ var shipCommand = new Core.Commands.Checkout.Shipping.ShipCommand() { NotifyCustomer = true, Shipment = new Domain.Shipping.Shipment() { } };
+ //Act
+ var result = await _shipCommandHandler.Handle(shipCommand, CancellationToken.None);
+ //Assert
+ _shipmentServiceMock.Verify(c => c.UpdateShipment(It.IsAny<Shipment>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Events/Customers/CustomerRegisteredEventHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Events/Customers/CustomerRegisteredEventHandlerTests.cs
new file mode 100644
index 000000000..8323dc702
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Events/Customers/CustomerRegisteredEventHandlerTests.cs
@@ -0,0 +1,42 @@
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Common.Localization;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Events.Customers.Tests
+{
+ [TestClass()]
+ public class CustomerRegisteredEventHandlerTests
+ {
+ CustomerRegisteredEventHandler _customerRegisteredEventHandler;
+ private Mock<ILoyaltyPointsService> _loyaltyPointsServiceMock;
+ private Domain.Orders.LoyaltyPointsSettings _loyaltyPointsSettings;
+ [TestInitialize()]
+ public void Init()
+ {
+ var translationServiceMock = new Mock<ITranslationService>();
+ translationServiceMock.Setup(x => x.GetResource(It.IsAny<string>())).Returns("Name");
+ _loyaltyPointsServiceMock = new Mock<ILoyaltyPointsService>();
+ _loyaltyPointsSettings = new Domain.Orders.LoyaltyPointsSettings() { Enabled = true, PointsForRegistration = 10 };
+ _customerRegisteredEventHandler = new CustomerRegisteredEventHandler(translationServiceMock.Object, _loyaltyPointsServiceMock.Object, _loyaltyPointsSettings);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest_LoyaltyPointsSettings_Enabled()
+ {
+ //Act
+ await _customerRegisteredEventHandler.Handle(new Core.Events.Customers.CustomerRegisteredEvent(new Domain.Customers.Customer()), 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);
+ }
+ [TestMethod()]
+ public async Task HandleTest_LoyaltyPointsSettings_Disabled()
+ {
+ _loyaltyPointsSettings.Enabled = false;
+ //Act
+ await _customerRegisteredEventHandler.Handle(new Core.Events.Customers.CustomerRegisteredEvent(new Domain.Customers.Customer()), 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.Never);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Events/Orders/MerchandiseReturnDeletedEventHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Events/Orders/MerchandiseReturnDeletedEventHandlerTests.cs
new file mode 100644
index 000000000..f4bee0491
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Events/Orders/MerchandiseReturnDeletedEventHandlerTests.cs
@@ -0,0 +1,39 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Grand.Business.Checkout.Events.Orders;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Moq;
+using Grand.Domain.Orders;
+
+namespace Grand.Business.Checkout.Events.Orders.Tests
+{
+ [TestClass()]
+ public class MerchandiseReturnDeletedEventHandlerTests
+ {
+ private MerchandiseReturnDeletedEventHandler _merchandiseReturnDeletedEventHandler;
+ private Mock<IOrderService> _orderServiceMock;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _orderServiceMock = new Mock<IOrderService>();
+ _merchandiseReturnDeletedEventHandler = new MerchandiseReturnDeletedEventHandler(_orderServiceMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ _orderServiceMock.Setup(x => x.GetOrderById(It.IsAny<string>())).Returns(Task.FromResult(new Order()));
+ var notification = new Infrastructure.Events.EntityDeleted<MerchandiseReturn>(new MerchandiseReturn());
+ //Act
+ await _merchandiseReturnDeletedEventHandler.Handle(notification, 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/Events/Orders/MerchandiseReturnInsertEventHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Events/Orders/MerchandiseReturnInsertEventHandlerTests.cs
new file mode 100644
index 000000000..4783c341a
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Events/Orders/MerchandiseReturnInsertEventHandlerTests.cs
@@ -0,0 +1,33 @@
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Domain.Orders;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Events.Orders.Tests
+{
+ [TestClass()]
+ public class MerchandiseReturnInsertEventHandlerTests
+ {
+ private MerchandiseReturnInsertEventHandler _merchandiseReturnInsertEventHandler;
+ private Mock<IOrderService> _orderServiceMock;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _orderServiceMock = new Mock<IOrderService>();
+ _merchandiseReturnInsertEventHandler = new MerchandiseReturnInsertEventHandler(_orderServiceMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ _orderServiceMock.Setup(x => x.GetOrderById(It.IsAny<string>())).Returns(Task.FromResult(new Order()));
+ var notification = new Infrastructure.Events.EntityInserted<MerchandiseReturn>(new MerchandiseReturn());
+ //Act
+ await _merchandiseReturnInsertEventHandler.Handle(notification, 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/Events/Orders/OrderDeletedEventHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Events/Orders/OrderDeletedEventHandlerTests.cs
new file mode 100644
index 000000000..1035cbd1b
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Events/Orders/OrderDeletedEventHandlerTests.cs
@@ -0,0 +1,34 @@
+using Grand.Business.Core.Events.Checkout.Orders;
+using Grand.Domain.Catalog;
+using Grand.Domain.Data;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Events.Orders.Tests
+{
+ [TestClass()]
+ public class OrderDeletedEventHandlerTests
+ {
+ private OrderDeletedEventHandler _orderDeletedEventHandler;
+ private Mock<IRepository<ProductAlsoPurchased>> _productAlsoPurchasedRepository;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _productAlsoPurchasedRepository = new Mock<IRepository<ProductAlsoPurchased>>();
+ _orderDeletedEventHandler = new OrderDeletedEventHandler(_productAlsoPurchasedRepository.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var order = new Domain.Orders.Order();
+ var notification = new OrderDeletedEvent(order);
+ //Act
+ await _orderDeletedEventHandler.Handle(notification, CancellationToken.None);
+ //Assert
+ _productAlsoPurchasedRepository.Verify(c => c.DeleteManyAsync(x => x.OrderId == notification.Order.Id), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Events/Orders/OrderPlacedEventHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Events/Orders/OrderPlacedEventHandlerTests.cs
new file mode 100644
index 000000000..69480bead
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Events/Orders/OrderPlacedEventHandlerTests.cs
@@ -0,0 +1,48 @@
+using Grand.Business.Core.Events.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Customers;
+using Grand.Domain.Catalog;
+using Grand.Domain.Data;
+using Grand.Domain.Orders;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Events.Orders.Tests
+{
+ [TestClass()]
+ public class OrderPlacedEventHandlerTests
+ {
+ private OrderPlacedEventHandler _orderPlacedEventHandler;
+ private Mock<IRepository<ProductAlsoPurchased>> _productAlsoPurchasedRepository;
+ private Mock<ICustomerService> _customerServiceMock;
+ private Mock<ILoyaltyPointsService> _loyaltyPointsServiceMock;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _productAlsoPurchasedRepository = new Mock<IRepository<ProductAlsoPurchased>>();
+ _customerServiceMock = new Mock<ICustomerService>();
+ _loyaltyPointsServiceMock = new Mock<ILoyaltyPointsService>();
+ _orderPlacedEventHandler = new OrderPlacedEventHandler(_productAlsoPurchasedRepository.Object, _customerServiceMock.Object, _loyaltyPointsServiceMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var order = new Order() { RedeemedLoyaltyPointsAmount = 10 };
+ order.OrderItems.Add(new OrderItem() { ProductId = "1" });
+ order.OrderItems.Add(new OrderItem() { ProductId = "2" });
+ var notification = new OrderPlacedEvent(order);
+ //Act
+ await _orderPlacedEventHandler.Handle(notification, CancellationToken.None);
+ //Assert
+ _productAlsoPurchasedRepository.Verify(c => c.InsertAsync(It.IsAny<ProductAlsoPurchased>()), Times.AtLeastOnce);
+ _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);
+ _customerServiceMock.Verify(c => c.UpdateCustomerField(order.CustomerId, x => x.FreeShipping, false), Times.Once);
+ _customerServiceMock.Verify(c => c.UpdateCustomerField(order.CustomerId, x => x.LastPurchaseDateUtc, order.CreatedOnUtc), Times.Once);
+ _customerServiceMock.Verify(c => c.UpdateCustomerField(order.CustomerId, x => x.LastUpdateCartDateUtc, null), Times.Once);
+ _customerServiceMock.Verify(c => c.UpdateCustomerField(order.CustomerId, x => x.HasContributions, true), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Events/Shipping/ShipmentDeletedEventHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Events/Shipping/ShipmentDeletedEventHandlerTests.cs
new file mode 100644
index 000000000..71b7c7f9e
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Events/Shipping/ShipmentDeletedEventHandlerTests.cs
@@ -0,0 +1,52 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Grand.Business.Checkout.Events.Shipping;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Grand.Business.Core.Interfaces.Customers;
+using Moq;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Business.Core.Interfaces.Checkout.Shipping;
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Grand.Domain.Shipping;
+using Grand.Domain.Orders;
+
+namespace Grand.Business.Checkout.Events.Shipping.Tests
+{
+ [TestClass()]
+ public class ShipmentDeletedEventHandlerTests
+ {
+ private ShipmentDeletedEventHandler _shipmentDeletedEventHandler;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IShipmentService> _shipmentServiceMock;
+ private Mock<IInventoryManageService> _inventoryManageServiceMock;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _orderServiceMock = new Mock<IOrderService>();
+ _shipmentServiceMock = new Mock<IShipmentService>();
+ _inventoryManageServiceMock = new Mock<IInventoryManageService>();
+ _shipmentDeletedEventHandler = new ShipmentDeletedEventHandler(_orderServiceMock.Object, _shipmentServiceMock.Object, _inventoryManageServiceMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var order = new Order();
+ _orderServiceMock.Setup(x => x.GetOrderById(It.IsAny<string>())).Returns(Task.FromResult(order));
+
+ var shipment = new Shipment();
+ shipment.ShipmentItems.Add(new ShipmentItem() { OrderItemId = "!" });
+ var notification = new Infrastructure.Events.EntityDeleted<Shipment>(shipment);
+ //Act
+ await _shipmentDeletedEventHandler.Handle(notification, CancellationToken.None);
+ //Assert
+ _inventoryManageServiceMock.Verify(x=>x.ReverseBookedInventory(It.IsAny<Shipment>(), It.IsAny<ShipmentItem>()), Times.Once);
+ _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/Events/Shipping/ShipmentInsertedEventHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Events/Shipping/ShipmentInsertedEventHandlerTests.cs
new file mode 100644
index 000000000..6df61bbdd
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Events/Shipping/ShipmentInsertedEventHandlerTests.cs
@@ -0,0 +1,46 @@
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Domain.Catalog;
+using Grand.Domain.Orders;
+using Grand.Domain.Shipping;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Events.Shipping.Tests
+{
+ [TestClass()]
+ public class ShipmentInsertedEventHandlerTests
+ {
+ private ShipmentInsertedEventHandler _shipmentInsertedEventHandler;
+ private Mock<IOrderService> _orderServiceMock;
+ private Mock<IProductService> _productServiceMock;
+ private Mock<IInventoryManageService> _inventoryManageServiceMock;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _orderServiceMock = new Mock<IOrderService>();
+ _productServiceMock = new Mock<IProductService>();
+ _inventoryManageServiceMock = new Mock<IInventoryManageService>();
+ _shipmentInsertedEventHandler = new ShipmentInsertedEventHandler(_orderServiceMock.Object, _productServiceMock.Object, _inventoryManageServiceMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var order = new Order();
+ _orderServiceMock.Setup(x => x.GetOrderById(It.IsAny<string>())).Returns(Task.FromResult(order));
+ _productServiceMock.Setup(x => x.GetProductById(It.IsAny<string>(), false)).Returns(Task.FromResult(new Domain.Catalog.Product()));
+
+ var shipment = new Shipment();
+ shipment.ShipmentItems.Add(new ShipmentItem() { OrderItemId = "!" });
+ var notification = new Infrastructure.Events.EntityInserted<Shipment>(shipment);
+ //Act
+ await _shipmentInsertedEventHandler.Handle(notification, CancellationToken.None);
+ //Assert
+ _inventoryManageServiceMock.Verify(x => x.BookReservedInventory(It.IsAny<Product>(), It.IsAny<Shipment>(), It.IsAny<ShipmentItem>()), Times.Once);
+ _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/Events/ShoppingCart/CustomerLoggedInEventHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Events/ShoppingCart/CustomerLoggedInEventHandlerTests.cs
new file mode 100644
index 000000000..4045b6475
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Events/ShoppingCart/CustomerLoggedInEventHandlerTests.cs
@@ -0,0 +1,35 @@
+using Grand.Business.Core.Interfaces.Checkout.Orders;
+using Grand.Domain.Customers;
+using Grand.Infrastructure;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Events.ShoppingCart.Tests
+{
+ [TestClass()]
+ public class CustomerLoggedInEventHandlerTests
+ {
+ private CustomerLoggedInEventHandler _customerLoggedInEventHandler;
+ private Mock<IShoppingCartService> _shoppingCartServiceMock;
+ private Mock<IWorkContext> _workContextMock;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _shoppingCartServiceMock = new Mock<IShoppingCartService>();
+ _workContextMock = new Mock<IWorkContext>();
+ _customerLoggedInEventHandler = new CustomerLoggedInEventHandler(_shoppingCartServiceMock.Object, _workContextMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ var notification = new Core.Events.Customers.CustomerLoggedInEvent(new Customer());
+ //Act
+ await _customerLoggedInEventHandler.Handle(notification, CancellationToken.None);
+ //Assert
+ _shoppingCartServiceMock.Verify(c => c.MigrateShoppingCart(It.IsAny<Customer>(), It.IsAny<Customer>(), true), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Events/ShoppingCart/ShoppingCartItemDeletedEventHandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Events/ShoppingCart/ShoppingCartItemDeletedEventHandlerTests.cs
new file mode 100644
index 000000000..41c4578fc
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Events/ShoppingCart/ShoppingCartItemDeletedEventHandlerTests.cs
@@ -0,0 +1,40 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Grand.Business.Checkout.Events.Shipping;
+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.Catalog;
+
+namespace Grand.Business.Checkout.Events.Shipping.Tests
+{
+ [TestClass()]
+ public class ShoppingCartItemDeletedEventHandlerTests
+ {
+ private ShoppingCartItemDeletedEventHandler _shoppingCartItemDeletedEventHandler;
+
+ private Mock<IProductReservationService> _productReservationServiceMock;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _productReservationServiceMock = new Mock<IProductReservationService>();
+ _shoppingCartItemDeletedEventHandler = new ShoppingCartItemDeletedEventHandler(_productReservationServiceMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task HandleTest()
+ {
+ //Arrange
+ _productReservationServiceMock.Setup(x => x.GetCustomerReservationsHelperBySciId(It.IsAny<string>())).Returns(Task.FromResult((IList<CustomerReservationsHelper>)new List<CustomerReservationsHelper>() { new CustomerReservationsHelper() }));
+ var notification = new Infrastructure.Events.EntityDeleted<Domain.Orders.ShoppingCartItem>(new Domain.Orders.ShoppingCartItem() { RentalStartDateUtc = DateTime.UtcNow, RentalEndDateUtc = DateTime.UtcNow});
+ //Act
+ await _shoppingCartItemDeletedEventHandler.Handle(notification, CancellationToken.None);
+ //Assert
+ _productReservationServiceMock.Verify(c => c.DeleteCustomerReservationsHelper(It.IsAny<CustomerReservationsHelper>()), Times.Once);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Queries/Handlers/Orders/HandlerTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Queries/Handlers/Orders/HandlerTests.cs
new file mode 100644
index 000000000..f54a85120
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Queries/Handlers/Orders/HandlerTests.cs
@@ -0,0 +1,252 @@
+using Grand.Business.Core.Interfaces.Checkout.Payments;
+using Grand.Business.Core.Queries.Checkout.Orders;
+using Grand.Domain.Orders;
+using Grand.Domain.Payments;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Checkout.Queries.Handlers.Orders.Tests
+{
+ [TestClass()]
+ public class HandlerTests
+ {
+ private Mock<IPaymentService> _paymentServiceMock;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _paymentServiceMock = new Mock<IPaymentService>();
+ _paymentServiceMock.Setup(x => x.SupportCapture(It.IsAny<string>())).Returns(Task.FromResult(true));
+ _paymentServiceMock.Setup(x => x.SupportRefund(It.IsAny<string>())).Returns(Task.FromResult(true));
+ _paymentServiceMock.Setup(x => x.SupportPartiallyRefund(It.IsAny<string>())).Returns(Task.FromResult(true));
+ _paymentServiceMock.Setup(x => x.SupportVoid(It.IsAny<string>())).Returns(Task.FromResult(true));
+ }
+
+ [TestMethod()]
+ public async Task CanCancelOrderQueryHandler_HandleTest_OrderStatus_Pending_True()
+ {
+ //Arrange
+ var canCancelOrderQueryHandler = new CanCancelOrderQueryHandler();
+ //Act
+ var result = await canCancelOrderQueryHandler.Handle(new CanCancelOrderQuery() { Order = new Order() { OrderStatusId = (int)OrderStatusSystem.Pending } }, CancellationToken.None);
+ //Assert
+ Assert.IsTrue(result);
+ }
+ [TestMethod()]
+ public async Task CanCancelOrderQueryHandler_HandleTest_OrderStatus_Processing_False()
+ {
+ //Arrange
+ var canCancelOrderQueryHandler = new CanCancelOrderQueryHandler();
+ //Act
+ var result = await canCancelOrderQueryHandler.Handle(new CanCancelOrderQuery() { Order = new Order() { OrderStatusId = (int)OrderStatusSystem.Processing } }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+
+
+ [TestMethod()]
+ public async Task CanCaptureQueryHandler_HandleTest_TransactionStatus_Authorized_True()
+ {
+ //Arrange
+ var canCaptureQueryHandler = new CanCaptureQueryHandler(_paymentServiceMock.Object);
+ //Act
+ var result = await canCaptureQueryHandler.Handle(new CanCaptureQuery() { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Authorized } }, CancellationToken.None);
+ //Assert
+ Assert.IsTrue(result);
+ }
+ [TestMethod()]
+ public async Task CanCaptureQueryHandler_HandleTest_TransactionStatus_Paid_False()
+ {
+ //Arrange
+ var canCaptureQueryHandler = new CanCaptureQueryHandler(_paymentServiceMock.Object);
+ //Act
+ var result = await canCaptureQueryHandler.Handle(new CanCaptureQuery() { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Paid } }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+ [TestMethod()]
+ public async Task CanMarkPaymentTransactionAsAuthorizedQueryHandler_HandleTest_TransactionStatus_Canceled_False()
+ {
+ //Arrange
+ var canMarkPaymentTransactionAsAuthorizedQueryHandler = new CanMarkPaymentTransactionAsAuthorizedQueryHandler();
+ //Act
+ var result = await canMarkPaymentTransactionAsAuthorizedQueryHandler.Handle(new CanMarkPaymentTransactionAsAuthorizedQuery() { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Canceled } }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+ [TestMethod()]
+ public async Task CanMarkPaymentTransactionAsAuthorizedQueryHandler_HandleTest_TransactionStatus_Pending_True()
+ {
+ //Arrange
+ var canMarkPaymentTransactionAsAuthorizedQueryHandler = new CanMarkPaymentTransactionAsAuthorizedQueryHandler();
+ //Act
+ var result = await canMarkPaymentTransactionAsAuthorizedQueryHandler.Handle(new CanMarkPaymentTransactionAsAuthorizedQuery() { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Pending } }, CancellationToken.None);
+ //Assert
+ Assert.IsTrue(result);
+ }
+ [TestMethod()]
+ public async Task CanMarkPaymentTransactionAsPaidQueryHandler_HandleTest_TransactionStatus_Authorized_True()
+ {
+ //Arrange
+ var canMarkPaymentTransactionAsPaidQueryHandler = new CanMarkPaymentTransactionAsPaidQueryHandler();
+ //Act
+ var result = await canMarkPaymentTransactionAsPaidQueryHandler.Handle(new CanMarkPaymentTransactionAsPaidQuery() { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Authorized } }, CancellationToken.None);
+ //Assert
+ Assert.IsTrue(result);
+ }
+ [TestMethod()]
+ public async Task CanMarkPaymentTransactionAsPaidQueryHandler_HandleTest_TransactionStatus_Canceled_False()
+ {
+ //Arrange
+ var canMarkPaymentTransactionAsPaidQueryHandler = new CanMarkPaymentTransactionAsPaidQueryHandler();
+ //Act
+ var result = await canMarkPaymentTransactionAsPaidQueryHandler.Handle(new CanMarkPaymentTransactionAsPaidQuery() { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Canceled } }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+
+ [TestMethod()]
+ public async Task CanPartiallyPaidOfflineQuery_HandleTest_TransactionStatus_Pending_True()
+ {
+ //Arrange
+ var canPartiallyPaidOfflineQueryHandler = new CanPartiallyPaidOfflineQueryHandler();
+ //Act
+ var result = await canPartiallyPaidOfflineQueryHandler.Handle(new CanPartiallyPaidOfflineQuery() { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Pending, TransactionAmount = 20 }, AmountToPaid = 10 }, CancellationToken.None);
+ //Assert
+ Assert.IsTrue(result);
+ }
+ [TestMethod()]
+ public async Task CanPartiallyPaidOfflineQuery_HandleTest_TransactionStatus_Paid_False()
+ {
+ //Arrange
+ var canPartiallyPaidOfflineQueryHandler = new CanPartiallyPaidOfflineQueryHandler();
+ //Act
+ var result = await canPartiallyPaidOfflineQueryHandler.Handle(new CanPartiallyPaidOfflineQuery() { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Paid, TransactionAmount = 20 }, AmountToPaid = 10 }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+ [TestMethod()]
+ public async Task CanPartiallyRefundOfflineQueryHandler_HandleTest_TransactionStatus_Pending_False()
+ {
+ //Arrange
+ var canPartiallyRefundOfflineQueryHandler = new CanPartiallyRefundOfflineQueryHandler();
+ //Act
+ var result = await canPartiallyRefundOfflineQueryHandler.Handle(new CanPartiallyRefundOfflineQuery() { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Pending, TransactionAmount = 20 } }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+ [TestMethod()]
+ public async Task CanPartiallyRefundOfflineQueryHandler_HandleTest_TransactionStatus_Paid_True()
+ {
+ //Arrange
+ var canPartiallyRefundOfflineQueryHandler = new CanPartiallyRefundOfflineQueryHandler();
+ //Act
+ var result = await canPartiallyRefundOfflineQueryHandler.Handle(new CanPartiallyRefundOfflineQuery() { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Pending, TransactionAmount = 20 } }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+
+ [TestMethod()]
+ public async Task CanPartiallyRefundQueryHandler_HandleTest_Paid_True()
+ {
+ //Arrange
+ var canPartiallyRefundQueryHandler = new CanPartiallyRefundQueryHandler(_paymentServiceMock.Object);
+ //Act
+ var result = await canPartiallyRefundQueryHandler.Handle(new CanPartiallyRefundQuery { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Paid, TransactionAmount = 10 } }, CancellationToken.None);
+ //Assert
+ Assert.IsTrue(result);
+ }
+ [TestMethod()]
+ public async Task CanPartiallyRefundQueryHandler_HandleTest_Pending_False()
+ {
+ //Arrange
+ var canPartiallyRefundQueryHandler = new CanPartiallyRefundQueryHandler(_paymentServiceMock.Object);
+ //Act
+ var result = await canPartiallyRefundQueryHandler.Handle(new CanPartiallyRefundQuery { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Pending } }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+ [TestMethod()]
+ public async Task CanRefundOfflineQueryHandler_HandleTest_Paid_True()
+ {
+ //Arrange
+ var canRefundOfflineQueryHandler = new CanRefundOfflineQueryHandler();
+ //Act
+ var result = await canRefundOfflineQueryHandler.Handle(new CanRefundOfflineQuery { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Paid, TransactionAmount = 10 } }, CancellationToken.None);
+ //Assert
+ Assert.IsTrue(result);
+ }
+ [TestMethod()]
+ public async Task CanRefundOfflineQueryHandler_HandleTest_Pending_False()
+ {
+ //Arrange
+ var canRefundOfflineQueryHandler = new CanRefundOfflineQueryHandler();
+ //Act
+ var result = await canRefundOfflineQueryHandler.Handle(new CanRefundOfflineQuery { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Pending, TransactionAmount = 10 } }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+ [TestMethod()]
+ public async Task CanRefundQueryHandler_HandleTest_Paid_True()
+ {
+ //Arrange
+ var canRefundQueryHandler = new CanRefundQueryHandler(_paymentServiceMock.Object);
+ //Act
+ var result = await canRefundQueryHandler.Handle(new CanRefundQuery { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Paid, TransactionAmount = 10 } }, CancellationToken.None);
+ //Assert
+ Assert.IsTrue(result);
+ }
+ [TestMethod()]
+ public async Task CanRefundQueryHandler_HandleTest_Paid_False()
+ {
+ //Arrange
+ var canRefundQueryHandler = new CanRefundQueryHandler(_paymentServiceMock.Object);
+ //Act
+ var result = await canRefundQueryHandler.Handle(new CanRefundQuery { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Pending, TransactionAmount = 10 } }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+ [TestMethod()]
+ public async Task CanVoidOfflineQueryHandler_HandleTest_Authorized_True()
+ {
+ //Arrange
+ var canVoidOfflineQueryHandler = new CanVoidOfflineQueryHandler();
+ //Act
+ var result = await canVoidOfflineQueryHandler.Handle(new CanVoidOfflineQuery { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Authorized, TransactionAmount = 10 } }, CancellationToken.None);
+ //Assert
+ Assert.IsTrue(result);
+ }
+ [TestMethod()]
+ public async Task CanVoidOfflineQueryHandler_HandleTest_PartialPaid_False()
+ {
+ //Arrange
+ var canVoidOfflineQueryHandler = new CanVoidOfflineQueryHandler();
+ //Act
+ var result = await canVoidOfflineQueryHandler.Handle(new CanVoidOfflineQuery { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.PartialPaid, TransactionAmount = 10 } }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+
+ [TestMethod()]
+ public async Task CanVoidQueryHandler_HandleTest_Authorized_True()
+ {
+ //Arrange
+ var canVoidQueryHandler = new CanVoidQueryHandler(_paymentServiceMock.Object);
+ //Act
+ var result = await canVoidQueryHandler.Handle(new CanVoidQuery { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Authorized, TransactionAmount = 10 } }, CancellationToken.None);
+ //Assert
+ Assert.IsTrue(result);
+ }
+ [TestMethod()]
+ public async Task CanVoidQueryHandler_HandleTest_Paid_Fals()
+ {
+ //Arrange
+ var canVoidQueryHandler = new CanVoidQueryHandler(_paymentServiceMock.Object);
+ //Act
+ var result = await canVoidQueryHandler.Handle(new CanVoidQuery { PaymentTransaction = new PaymentTransaction() { TransactionStatus = TransactionStatus.Paid, TransactionAmount = 10 } }, CancellationToken.None);
+ //Assert
+ Assert.IsFalse(result);
+ }
+
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Checkout.Tests/Startup/StartupApplicationTests.cs b/src/Tests/Grand.Business.Checkout.Tests/Startup/StartupApplicationTests.cs
new file mode 100644
index 000000000..4814e382b
--- /dev/null
+++ b/src/Tests/Grand.Business.Checkout.Tests/Startup/StartupApplicationTests.cs
@@ -0,0 +1,31 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Grand.Business.Checkout.Startup.Tests
+{
+ [TestClass()]
+ public class StartupApplicationTests
+ {
+ StartupApplication _application;
+ ServiceCollection _serviceCollection;
+ IConfiguration _configuration;
+
+ [TestInitialize]
+ public void Init()
+ {
+ _serviceCollection = new ServiceCollection();
+ _configuration = new ConfigurationBuilder().Build();
+ _application = new StartupApplication();
+
+ }
+ [TestMethod()]
+ public void ConfigureServicesTest()
+ {
+ //Act
+ _application.ConfigureServices(_serviceCollection, _configuration);
+ //Assert
+ Assert.IsTrue(_serviceCollection.Count > 0);
+ }
+ }
+}
\ No newline at end of file