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.
C# aspnet-corecsharpdockerdotnetecommerceecommerce-platformmongodbmulti-storemulti-vendornosqlonline-shopshoppingcart
using Grand.Business.Core.Interfaces.Checkout.Orders;
using Grand.Business.Core.Interfaces.Common.Localization;
using Grand.Business.Core.Interfaces.Common.Pdf;
using Grand.Domain.Localization;
using Grand.Domain.Orders;
using Grand.Infrastructure;
using Grand.Web.AdminShared.Controllers;
using Grand.Web.AdminShared.Interfaces;
using Grand.Web.AdminShared.Models.Orders;
using Grand.Web.Common.DataSource;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Routing;
using Microsoft.AspNetCore.Mvc.ViewFeatures;
using Microsoft.Extensions.Logging;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
namespace Grand.Web.Admin.Tests.Controllers;
[TestClass]
public class BaseOrderControllerTests
{
// BaseOrderController is abstract; minimal subclass so actions can be invoked directly.
private class TestOrderController(
IOrderViewModelService orderViewModelService,
IOrderService orderService,
ITranslationService translationService,
IContextAccessor contextAccessor,
IPdfService pdfService,
IAdminDataScope<Order> scope)
: BaseOrderController(orderViewModelService, orderService, translationService,
contextAccessor, pdfService, scope)
{
public Task<(Order order, IActionResult denied)> LoadAuthorizedOrderPublic(string id) =>
LoadAuthorizedOrder(id);
}
private TestOrderController _controller;
private Mock<IOrderService> _orderServiceMock;
private Mock<IOrderViewModelService> _orderViewModelServiceMock;
private Mock<IAdminDataScope<Order>> _scopeMock;
private Mock<IPdfService> _pdfServiceMock;
[TestInitialize]
public void Setup()
{
_orderServiceMock = new Mock<IOrderService>();
_orderViewModelServiceMock = new Mock<IOrderViewModelService>();
_scopeMock = new Mock<IAdminDataScope<Order>>();
_scopeMock.Setup(s => s.DefaultStoreId).Returns((string)null);
_pdfServiceMock = new Mock<IPdfService>();
var translationServiceMock = new Mock<ITranslationService>();
translationServiceMock.Setup(t => t.GetResource(It.IsAny<string>())).Returns("resource");
var contextAccessorMock = new Mock<IContextAccessor>();
var workContextMock = new Mock<IWorkContext>();
workContextMock.Setup(w => w.WorkingLanguage).Returns(new Language { Id = "lang-1" });
contextAccessorMock.Setup(c => c.WorkContext).Returns(workContextMock.Object);
_controller = new TestOrderController(
_orderViewModelServiceMock.Object,
_orderServiceMock.Object,
translationServiceMock.Object,
contextAccessorMock.Object,
_pdfServiceMock.Object,
_scopeMock.Object);
var httpContext = new DefaultHttpContext();
var loggerFactoryMock = new Mock<ILoggerFactory>();
loggerFactoryMock.Setup(l => l.CreateLogger(It.IsAny<string>())).Returns(new Mock<ILogger>().Object);
var urlHelperFactoryMock = new Mock<IUrlHelperFactory>();
urlHelperFactoryMock.Setup(f => f.GetUrlHelper(It.IsAny<ActionContext>())).Returns(new Mock<IUrlHelper>().Object);
var requestServicesMock = new Mock<IServiceProvider>();
requestServicesMock.Setup(s => s.GetService(typeof(ILoggerFactory))).Returns(loggerFactoryMock.Object);
requestServicesMock.Setup(s => s.GetService(typeof(IUrlHelperFactory))).Returns(urlHelperFactoryMock.Object);
httpContext.RequestServices = requestServicesMock.Object;
_controller.ControllerContext = new ControllerContext { HttpContext = httpContext };
_controller.TempData = new TempDataDictionary(httpContext, new Mock<ITempDataProvider>().Object);
}
[TestMethod]
public async Task ListGet_CallsPrepareOrderListModel_WithScopeDefaultStoreId()
{
_scopeMock.Setup(s => s.DefaultStoreId).Returns("store-1");
_orderViewModelServiceMock
.Setup(v => v.PrepareOrderListModel(null, null, null, null, "store-1", null))
.ReturnsAsync(new OrderListModel());
var result = await _controller.List();
Assert.IsInstanceOfType(result, typeof(ViewResult));
_orderViewModelServiceMock.Verify(v => v.PrepareOrderListModel(null, null, null, null, "store-1", null), Times.Once);
}
[TestMethod]
public async Task ListGet_GlobalScope_PassesEmptyStoreId()
{
_scopeMock.Setup(s => s.DefaultStoreId).Returns((string)null);
_orderViewModelServiceMock
.Setup(v => v.PrepareOrderListModel(null, null, null, null, "", null))
.ReturnsAsync(new OrderListModel());
await _controller.List();
_orderViewModelServiceMock.Verify(v => v.PrepareOrderListModel(null, null, null, null, "", null), Times.Once);
}
[TestMethod]
public async Task ListPost_StoreScope_ForcesModelStoreId()
{
_scopeMock.Setup(s => s.DefaultStoreId).Returns("store-1");
_orderViewModelServiceMock
.Setup(v => v.PrepareOrderModel(It.IsAny<OrderListModel>(), 1, 10))
.ReturnsAsync((Enumerable.Empty<OrderModel>(), 0));
var model = new OrderListModel { StoreId = "attacker-supplied" };
await _controller.OrderList(new DataSourceRequest { Page = 1, PageSize = 10 }, model);
Assert.AreEqual("store-1", model.StoreId);
}
[TestMethod]
public async Task ListPost_GlobalScope_LeavesSubmittedStoreIdUntouched()
{
_scopeMock.Setup(s => s.DefaultStoreId).Returns((string)null);
_orderViewModelServiceMock
.Setup(v => v.PrepareOrderModel(It.IsAny<OrderListModel>(), 1, 10))
.ReturnsAsync((Enumerable.Empty<OrderModel>(), 0));
var model = new OrderListModel { StoreId = "admin-submitted" };
await _controller.OrderList(new DataSourceRequest { Page = 1, PageSize = 10 }, model);
Assert.AreEqual("admin-submitted", model.StoreId);
}
[TestMethod]
public async Task ListPost_VendorScope_ForcesModelVendorId()
{
_scopeMock.Setup(s => s.DefaultStoreId).Returns((string)null);
_scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor-A");
_orderViewModelServiceMock
.Setup(v => v.PrepareOrderModel(It.IsAny<OrderListModel>(), 1, 10))
.ReturnsAsync((Enumerable.Empty<OrderModel>(), 0));
var model = new OrderListModel();
await _controller.OrderList(new DataSourceRequest { Page = 1, PageSize = 10 }, model);
Assert.AreEqual("vendor-A", model.VendorId);
}
[TestMethod]
public async Task LoadAuthorizedOrder_NotFound_ReturnsRedirectToList()
{
_orderServiceMock.Setup(s => s.GetOrderById("missing")).ReturnsAsync((Order)null);
var (order, denied) = await _controller.LoadAuthorizedOrderPublic("missing");
Assert.IsNull(order);
var redirect = denied as RedirectToActionResult;
Assert.IsNotNull(redirect);
Assert.AreEqual("List", redirect.ActionName);
_scopeMock.Verify(s => s.HasAccess(It.IsAny<Order>()), Times.Never);
}
[TestMethod]
public async Task LoadAuthorizedOrder_ScopeDenies_ReturnsRedirectToList()
{
var order = new Order { Id = "o1" };
_orderServiceMock.Setup(s => s.GetOrderById("o1")).ReturnsAsync(order);
_scopeMock.Setup(s => s.HasAccess(order)).ReturnsAsync(false);
var (resultOrder, denied) = await _controller.LoadAuthorizedOrderPublic("o1");
Assert.IsNull(resultOrder);
var redirect = denied as RedirectToActionResult;
Assert.IsNotNull(redirect);
Assert.AreEqual("List", redirect.ActionName);
}
[TestMethod]
public async Task LoadAuthorizedOrder_ScopeAllows_ReturnsOrderNoDenial()
{
var order = new Order { Id = "o1" };
_orderServiceMock.Setup(s => s.GetOrderById("o1")).ReturnsAsync(order);
_scopeMock.Setup(s => s.HasAccess(order)).ReturnsAsync(true);
var (resultOrder, denied) = await _controller.LoadAuthorizedOrderPublic("o1");
Assert.AreSame(order, resultOrder);
Assert.IsNull(denied);
}
[TestMethod]
public async Task EditGet_NotFound_RedirectsToList()
{
_orderServiceMock.Setup(s => s.GetOrderById("missing")).ReturnsAsync((Order)null);
var result = await _controller.Edit("missing");
var redirect = result as RedirectToActionResult;
Assert.IsNotNull(redirect);
Assert.AreEqual("List", redirect.ActionName);
}
[TestMethod]
public async Task EditGet_Deleted_RedirectsToList()
{
var order = new Order { Id = "o1", Deleted = true };
_orderServiceMock.Setup(s => s.GetOrderById("o1")).ReturnsAsync(order);
_scopeMock.Setup(s => s.HasAccess(order)).ReturnsAsync(true);
var result = await _controller.Edit("o1");
var redirect = result as RedirectToActionResult;
Assert.IsNotNull(redirect);
Assert.AreEqual("List", redirect.ActionName);
}
[TestMethod]
public async Task EditGet_ScopeDenies_RedirectsToList()
{
var order = new Order { Id = "o1" };
_orderServiceMock.Setup(s => s.GetOrderById("o1")).ReturnsAsync(order);
_scopeMock.Setup(s => s.HasAccess(order)).ReturnsAsync(false);
var result = await _controller.Edit("o1");
var redirect = result as RedirectToActionResult;
Assert.IsNotNull(redirect);
Assert.AreEqual("List", redirect.ActionName);
}
[TestMethod]
public async Task EditGet_Authorized_ReturnsViewAndCallsPrepareOrderDetailsModel()
{
var order = new Order { Id = "o1" };
_orderServiceMock.Setup(s => s.GetOrderById("o1")).ReturnsAsync(order);
_scopeMock.Setup(s => s.HasAccess(order)).ReturnsAsync(true);
var result = await _controller.Edit("o1");
Assert.IsInstanceOfType(result, typeof(ViewResult));
_orderViewModelServiceMock.Verify(v => v.PrepareOrderDetailsModel(It.IsAny<OrderModel>(), order), Times.Once);
}
[TestMethod]
public async Task ProductSearchAutoComplete_VendorScope_ForcesVendorIdIntoSearch()
{
_scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor-A");
// NOTE: brief's test used named-argument Setup/Verify calls (storeId:/vendorId:/keywords:/
// pageSize:/showHidden:), which don't compile: (1) named arguments inside a Moq Setup
// expression tree must appear in the same relative order as the method's declared parameter
// list - the brief's order (storeId, vendorId, keywords, pageSize, showHidden) puts pageSize
// (declared 3rd) after storeId/vendorId/keywords (declared 7th/8th/18th), which the compiler
// rejects as CS9307 "named argument specification out of position"; and (2) IProductService.
// SearchProducts actually returns Task<(IPagedList<Product>, IList<string>)>, not
// Task<(List<Product>, int)> as the brief's ReturnsAsync assumed. Rewritten below as a fully
// positional call (all 27 parameters, It.IsAny<T>() for the ones this test doesn't care
// about) to test the same behavior: the controller forces scope.DefaultVendorId into the
// vendorId slot alongside the caller-supplied term/pageSize/showHidden.
var productServiceMock = new Mock<Grand.Business.Core.Interfaces.Catalog.Products.IProductService>();
var pagedProducts = (Grand.Domain.IPagedList<Grand.Domain.Catalog.Product>)
new Grand.Domain.PagedList<Grand.Domain.Catalog.Product>(new List<Grand.Domain.Catalog.Product>(), 0, 15);
productServiceMock
.Setup(p => p.SearchProducts(
It.IsAny<bool>(), It.IsAny<int>(), 15, It.IsAny<IList<string>>(), It.IsAny<string>(), It.IsAny<string>(),
null, "vendor-A", It.IsAny<string>(), It.IsAny<Grand.Domain.Catalog.ProductType?>(), It.IsAny<bool>(),
It.IsAny<bool>(), It.IsAny<bool?>(), It.IsAny<bool?>(), It.IsAny<double?>(), It.IsAny<double?>(),
It.IsAny<string>(), "abc", It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<string>(),
It.IsAny<IList<string>>(), It.IsAny<IList<string>>(), It.IsAny<Grand.Domain.Catalog.ProductSortingEnum>(),
true, It.IsAny<bool?>()))
.ReturnsAsync((pagedProducts, (IList<string>)new List<string>()));
await _controller.ProductSearchAutoComplete("abc", productServiceMock.Object);
productServiceMock.Verify(p => p.SearchProducts(
It.IsAny<bool>(), It.IsAny<int>(), 15, It.IsAny<IList<string>>(), It.IsAny<string>(), It.IsAny<string>(),
null, "vendor-A", It.IsAny<string>(), It.IsAny<Grand.Domain.Catalog.ProductType?>(), It.IsAny<bool>(),
It.IsAny<bool>(), It.IsAny<bool?>(), It.IsAny<bool?>(), It.IsAny<double?>(), It.IsAny<double?>(),
It.IsAny<string>(), "abc", It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<string>(),
It.IsAny<IList<string>>(), It.IsAny<IList<string>>(), It.IsAny<Grand.Domain.Catalog.ProductSortingEnum>(),
true, It.IsAny<bool?>()), Times.Once);
}
[TestMethod]
public async Task PdfInvoice_ThreadsScopeDefaultVendorId()
{
var order = new Order { Id = "o1" };
_orderServiceMock.Setup(s => s.GetOrderById("o1")).ReturnsAsync(order);
_scopeMock.Setup(s => s.HasAccess(order)).ReturnsAsync(true);
_scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor-A");
var result = await _controller.PdfInvoice("o1");
Assert.IsInstanceOfType(result, typeof(FileContentResult));
_pdfServiceMock.Verify(
p => p.PrintOrdersToPdf(It.IsAny<Stream>(), It.Is<IList<Order>>(l => l.Count == 1 && l[0] == order),
"lang-1", "vendor-A"), Times.Once);
}
[TestMethod]
public async Task PdfInvoiceAll_ThreadsScopeDefaultVendorId()
{
_scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor-A");
var orders = new List<Order> { new() { Id = "o1" } };
_orderViewModelServiceMock.Setup(v => v.PrepareOrders(It.IsAny<OrderListModel>()))
.ReturnsAsync((IList<Order>)orders);
var result = await _controller.PdfInvoiceAll(new OrderListModel());
Assert.IsInstanceOfType(result, typeof(FileContentResult));
_pdfServiceMock.Verify(
p => p.PrintOrdersToPdf(It.IsAny<Stream>(), It.IsAny<IList<Order>>(), "lang-1", "vendor-A"),
Times.Once);
}
[TestMethod]
public async Task PdfInvoiceSelected_ThreadsScopeDefaultVendorId()
{
// Direct regression guard for the final review C2 fix: PdfInvoiceSelected must pass
// scope.DefaultVendorId to IPdfService.PrintOrdersToPdf, matching PdfInvoice/PdfInvoiceAll.
_scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor-A");
var order = new Order { Id = "o1" };
_orderServiceMock.Setup(s => s.GetOrdersByIds(It.Is<string[]>(ids => ids.Length == 1 && ids[0] == "o1")))
.ReturnsAsync((IList<Order>)new List<Order> { order });
_scopeMock.Setup(s => s.HasAccess(order)).ReturnsAsync(true);
var result = await _controller.PdfInvoiceSelected("o1");
Assert.IsInstanceOfType(result, typeof(FileContentResult));
_pdfServiceMock.Verify(
p => p.PrintOrdersToPdf(It.IsAny<Stream>(), It.Is<IList<Order>>(l => l.Count == 1 && l[0] == order),
"lang-1", "vendor-A"), Times.Once);
}
[TestMethod]
public async Task PdfInvoiceSelected_ScopeDenies_ExcludesOrderFromPdf()
{
var order = new Order { Id = "o1" };
_orderServiceMock.Setup(s => s.GetOrdersByIds(It.IsAny<string[]>()))
.ReturnsAsync((IList<Order>)new List<Order> { order });
_scopeMock.Setup(s => s.HasAccess(order)).ReturnsAsync(false);
var result = await _controller.PdfInvoiceSelected("o1");
var redirect = result as RedirectToActionResult;
Assert.IsNotNull(redirect);
Assert.AreEqual("List", redirect.ActionName);
_pdfServiceMock.Verify(
p => p.PrintOrdersToPdf(It.IsAny<Stream>(), It.IsAny<IList<Order>>(), It.IsAny<string>(), It.IsAny<string>()),
Times.Never);
}
[TestMethod]
public async Task GoToOrderId_ScopeDenies_RedirectsToList()
{
var order = new Order { Id = "o1" };
_orderServiceMock.Setup(s => s.GetOrderByNumber(7)).ReturnsAsync(order);
_scopeMock.Setup(s => s.HasAccess(order)).ReturnsAsync(false);
var result = await _controller.GoToOrderId(new OrderListModel { GoDirectlyToNumber = "7" });
var redirect = result as RedirectToActionResult;
Assert.IsNotNull(redirect);
Assert.AreEqual("List", redirect.ActionName);
}
}