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.

28.7 KB
Raw Blame
using Grand.Business.Core.Interfaces.Catalog.Brands;
using Grand.Business.Core.Interfaces.Catalog.Categories;
using Grand.Business.Core.Interfaces.Catalog.Collections;
using Grand.Business.Core.Interfaces.Catalog.Directory;
using Grand.Business.Core.Interfaces.Catalog.Discounts;
using Grand.Business.Core.Interfaces.Catalog.Prices;
using Grand.Business.Core.Interfaces.Catalog.Products;
using Grand.Business.Core.Interfaces.Catalog.Tax;
using Grand.Business.Core.Interfaces.Checkout.Shipping;
using Grand.Business.Core.Interfaces.Common.Directory;
using Grand.Business.Core.Interfaces.Common.Localization;
using Grand.Business.Core.Interfaces.Common.Seo;
using Grand.Business.Core.Interfaces.Common.Stores;
using Grand.Business.Core.Interfaces.Customers;
using Grand.Business.Core.Interfaces.Storage;
using Grand.Domain;
using Grand.Domain.Catalog;
using Grand.Domain.Customers;
using Grand.Domain.Directory;
using Grand.Domain.Discounts;
using Grand.Domain.Media;
using Grand.Domain.Seo;
using Grand.Domain.Shipping;
using Grand.Domain.Stores;
using Grand.Domain.Tax;
using Grand.Domain.Vendors;
using Grand.Infrastructure;
using Grand.Infrastructure.Mapper;
using Grand.Mapping;
using Grand.Web.AdminShared.Interfaces;
using Grand.Web.AdminShared.Mapper;
using Grand.Web.AdminShared.Models.Catalog;
using Grand.Web.AdminShared.Services;
using Grand.Web.Common.Localization;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using Assert = Microsoft.VisualStudio.TestTools.UnitTesting.Assert;

namespace Grand.Web.Admin.Tests.Services;

[TestClass]
public class ProductViewModelServiceTests
{
    private const string StaffStoreId = "staffStoreId";

    private Mock<IDiscountService> _discountServiceMock;
    private Mock<IEnumTranslationService> _enumTranslationServiceMock;
    private Mock<IGroupService> _groupServiceMock;
    private Mock<IMeasureService> _measureServiceMock;
    private Mock<IProductService> _productServiceMock;
    private ProductViewModelService _productViewModelService;
    private Mock<IAdminDataScope<Product>> _scopeMock;
    private Mock<IStoreService> _storeServiceMock;
    private Mock<ITaxCategoryService> _taxCategoryServiceMock;
    private Mock<ITranslationService> _translationServiceMock;
    private Mock<IVendorService> _vendorServiceMock;
    private Mock<IWarehouseService> _warehouseServiceMock;

    [TestInitialize]
    public void Setup()
    {
        var mapperConfig = new MapperConfiguration(cfg => { cfg.AddProfile<ProductProfile>(); });
        AutoMapperConfig.Init(mapperConfig);

        _discountServiceMock = new Mock<IDiscountService>();
        _enumTranslationServiceMock = new Mock<IEnumTranslationService>();
        _groupServiceMock = new Mock<IGroupService>();
        _measureServiceMock = new Mock<IMeasureService>();
        _productServiceMock = new Mock<IProductService>();
        _storeServiceMock = new Mock<IStoreService>();
        _taxCategoryServiceMock = new Mock<ITaxCategoryService>();
        _translationServiceMock = new Mock<ITranslationService>();
        _vendorServiceMock = new Mock<IVendorService>();
        _warehouseServiceMock = new Mock<IWarehouseService>();

        _translationServiceMock.Setup(t => t.GetResource(It.IsAny<string>())).Returns("resource");

        var workContextMock = new Mock<IWorkContext>();
        workContextMock.Setup(w => w.CurrentCustomer).Returns(new Customer { StaffStoreId = StaffStoreId });
        var contextAccessorMock = new Mock<IContextAccessor>();
        contextAccessorMock.Setup(c => c.WorkContext).Returns(workContextMock.Object);

        var currencyServiceMock = new Mock<ICurrencyService>();
        currencyServiceMock.Setup(c => c.GetCurrencyById(It.IsAny<string>())).ReturnsAsync((Currency)null);
        currencyServiceMock.Setup(c => c.GetAllCurrencies(It.IsAny<bool>(), It.IsAny<string>())).ReturnsAsync(new List<Currency>());
        _measureServiceMock.Setup(m => m.GetMeasureWeightById(It.IsAny<string>())).ReturnsAsync((MeasureWeight)null);
        _measureServiceMock.Setup(m => m.GetMeasureDimensionById(It.IsAny<string>()))
            .ReturnsAsync((MeasureDimension)null);
        _measureServiceMock.Setup(m => m.GetAllMeasureWeights()).ReturnsAsync(new List<MeasureWeight>());
        _measureServiceMock.Setup(m => m.GetAllMeasureUnits()).ReturnsAsync(new List<MeasureUnit>());

        var productLayoutServiceMock = new Mock<IProductLayoutService>();
        productLayoutServiceMock.Setup(p => p.GetAllProductLayouts()).ReturnsAsync(new List<ProductLayout>());

        var deliveryDateServiceMock = new Mock<IDeliveryDateService>();
        deliveryDateServiceMock
            .Setup(d => d.GetAllDeliveryDates(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>()))
            .ReturnsAsync(new PagedList<DeliveryDate>());

        _warehouseServiceMock
            .Setup(w => w.GetAllWarehouses(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>()))
            .ReturnsAsync(new PagedList<Warehouse>());

        _taxCategoryServiceMock.Setup(t => t.GetAllTaxCategories(It.IsAny<string>()))
            .ReturnsAsync(new List<TaxCategory>());

        _discountServiceMock.Setup(d => d.GetDiscountsQuery(It.IsAny<DiscountType?>(), It.IsAny<string>(),
                It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
            .ReturnsAsync(new List<Discount>());

        _storeServiceMock.Setup(s => s.GetAllStores()).ReturnsAsync(new List<Store>());

        _groupServiceMock.Setup(g => g.GetAllCustomerGroups(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<bool>()))
            .ReturnsAsync(new PagedList<CustomerGroup>());

        _enumTranslationServiceMock
            .Setup(e => e.ToSelectList(It.IsAny<ProductType>(), It.IsAny<bool>(), It.IsAny<int[]>()))
            .Returns(new SelectList(Enumerable.Empty<SelectListItem>()));

        // Default: Admin's Global scope - no default store/vendor, homepage option and store dropdown both show.
        _scopeMock = new Mock<IAdminDataScope<Product>>();
        _scopeMock.Setup(s => s.DefaultStoreId).Returns((string)null);
        _scopeMock.Setup(s => s.ResourceKeyPrefix).Returns("Admin");
        _scopeMock.Setup(s => s.ShowStoreSelector).Returns(true);
        _scopeMock.Setup(s => s.DefaultVendorId).Returns((string)null);
        _scopeMock.Setup(s => s.CanFeatureOnHomepage).Returns(true);

        _productViewModelService = new ProductViewModelService(
            _productServiceMock.Object,
            new Mock<IInventoryManageService>().Object,
            new Mock<IPictureService>().Object,
            new Mock<IProductAttributeService>().Object,
            new Mock<IProductTagService>().Object,
            currencyServiceMock.Object,
            _measureServiceMock.Object,
            new Mock<IDateTimeService>().Object,
            new Mock<IBrandService>().Object,
            new Mock<ICollectionService>().Object,
            new Mock<IProductCollectionService>().Object,
            new Mock<ICategoryService>().Object,
            new Mock<IProductCategoryService>().Object,
            _vendorServiceMock.Object,
            _translationServiceMock.Object,
            productLayoutServiceMock.Object,
            new Mock<ISpecificationAttributeService>().Object,
            contextAccessorMock.Object,
            _groupServiceMock.Object,
            _warehouseServiceMock.Object,
            deliveryDateServiceMock.Object,
            _taxCategoryServiceMock.Object,
            _discountServiceMock.Object,
            new Mock<ICustomerService>().Object,
            _storeServiceMock.Object,
            new Mock<IOutOfStockSubscriptionService>().Object,
            new Mock<IDownloadService>().Object,
            new Mock<ILanguageService>().Object,
            new Mock<IProductAttributeFormatter>().Object,
            new Mock<IStockQuantityService>().Object,
            new CurrencySettings(),
            new MeasureSettings(),
            new TaxSettings(),
            new SeoSettings(),
            new Mock<IAuctionService>().Object,
            new Mock<IPriceFormatter>().Object,
            new Mock<ISeNameService>().Object,
            _enumTranslationServiceMock.Object,
            _scopeMock.Object);
    }

    [TestMethod]
    public async Task PrepareProductModel_UseStaffStoreIdForTaxCategories()
    {
        _taxCategoryServiceMock.Setup(t => t.GetAllTaxCategories(StaffStoreId))
            .ReturnsAsync(new List<TaxCategory> { new() { Id = "taxId", Name = "Standard" } });

        var model = new ProductModel();
        await _productViewModelService.PrepareProductModel(model, null, false, false);

        _taxCategoryServiceMock.Verify(t => t.GetAllTaxCategories(StaffStoreId), Times.Once);
        Assert.IsTrue(model.AvailableTaxCategories.Any(x => x.Value == "taxId"));
    }

    [TestMethod]
    public async Task PrepareProductModel_UseStaffStoreIdForDiscounts()
    {
        var model = new ProductModel();
        await _productViewModelService.PrepareProductModel(model, null, false, false);

        _discountServiceMock.Verify(d => d.GetDiscountsQuery(DiscountType.AssignedToSkus, StaffStoreId,
            It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
    }

    [TestMethod]
    public async Task PrepareProductModel_UseModelStoreIdForWarehouses()
    {
        _warehouseServiceMock
            .Setup(w => w.GetAllWarehouses("modelStoreId", It.IsAny<int>(), It.IsAny<int>()))
            .ReturnsAsync(new PagedList<Warehouse> { new() { Id = "warehouseId", Name = "Main" } });

        var model = new ProductModel { StoreId = "modelStoreId" };
        await _productViewModelService.PrepareProductModel(model, null, false, false);

        _warehouseServiceMock.Verify(w => w.GetAllWarehouses("modelStoreId", It.IsAny<int>(), It.IsAny<int>()),
            Times.Once);
        Assert.IsTrue(model.AvailableWarehouses.Any(x => x.Value == "warehouseId"));
    }

    [TestMethod]
    public async Task PrepareProductListModel_UseStoreIdForWarehouses()
    {
        _scopeMock.Setup(s => s.DefaultStoreId).Returns(StaffStoreId);
        _warehouseServiceMock
            .Setup(w => w.GetAllWarehouses(StaffStoreId, It.IsAny<int>(), It.IsAny<int>()))
            .ReturnsAsync(new PagedList<Warehouse> { new() { Id = "warehouseId", Name = "Main" } });

        var model = await _productViewModelService.PrepareProductListModel();

        _warehouseServiceMock.Verify(w => w.GetAllWarehouses(StaffStoreId, It.IsAny<int>(), It.IsAny<int>()),
            Times.Once);
        Assert.IsTrue(model.AvailableWarehouses.Any(x => x.Value == "warehouseId"));
    }

    [TestMethod]
    public async Task PrepareProductListModel_FilterStoresByStoreId()
    {
        _scopeMock.Setup(s => s.DefaultStoreId).Returns("store1");
        _storeServiceMock.Setup(s => s.GetAllStores()).ReturnsAsync(new List<Store> {
            new() { Id = "store1", Shortcut = "Store 1" },
            new() { Id = "store2", Shortcut = "Store 2" }
        });

        var model = await _productViewModelService.PrepareProductListModel();

        Assert.IsTrue(model.AvailableStores.Any(x => x.Value == "store1"));
        Assert.IsFalse(model.AvailableStores.Any(x => x.Value == "store2"));
    }

    [TestMethod]
    public async Task PrepareProductListModel_GlobalScope_IncludesHomepageOptionAndStoreDropdown()
    {
        // Default Setup() scope: Admin's Global scope (DefaultStoreId null, ShowStoreSelector true).
        _storeServiceMock.Setup(s => s.GetAllStores()).ReturnsAsync(new List<Store> {
            new() { Id = "store1", Shortcut = "Store 1" }
        });

        var model = await _productViewModelService.PrepareProductListModel();

        Assert.IsTrue(model.AvailablePublishedOptions.Any(x => x.Value == "3"),
            "Admin should offer the 'Show on homepage' option.");
        Assert.IsTrue(model.AvailableStores.Any(x => x.Value == "store1"),
            "Admin should offer a store dropdown.");
    }

    [TestMethod]
    public async Task PrepareProductListModel_VendorScope_HidesHomepageOptionAndStoreDropdown()
    {
        _scopeMock.Setup(s => s.DefaultStoreId).Returns((string)null);
        _scopeMock.Setup(s => s.ResourceKeyPrefix).Returns("Vendor");
        _scopeMock.Setup(s => s.ShowStoreSelector).Returns(false);
        _scopeMock.Setup(s => s.CanFeatureOnHomepage).Returns(false);
        _storeServiceMock.Setup(s => s.GetAllStores()).ReturnsAsync(new List<Store> {
            new() { Id = "store1", Shortcut = "Store 1" }
        });

        var model = await _productViewModelService.PrepareProductListModel();

        Assert.IsFalse(model.AvailablePublishedOptions.Any(x => x.Value == "3"),
            "Vendor can't feature products on the homepage.");
        Assert.IsFalse(model.AvailableStores.Any(),
            "Vendor doesn't pick stores - no dropdown should be populated at all.");
    }

    [TestMethod]
    public async Task PrepareTierPriceModel_VendorScope_HidesStoreDropdown()
    {
        _scopeMock.Setup(s => s.DefaultStoreId).Returns((string)null);
        _scopeMock.Setup(s => s.ResourceKeyPrefix).Returns("Vendor");
        _scopeMock.Setup(s => s.ShowStoreSelector).Returns(false);
        _storeServiceMock.Setup(s => s.GetAllStores()).ReturnsAsync(new List<Store> {
            new() { Id = "store1", Shortcut = "Store 1" }
        });

        var model = new ProductModel.TierPriceModel();
        await _productViewModelService.PrepareTierPriceModel(model);

        Assert.IsFalse(model.AvailableStores.Any(),
            "Vendor doesn't pick stores - no dropdown should be populated at all, matching the original Vendor service's PrepareTierPriceModel.");
    }

    [TestMethod]
    public async Task PrepareTierPriceModel_GlobalScope_IncludesStoreDropdown()
    {
        // Default Setup() scope: Admin's Global scope (DefaultStoreId null, ShowStoreSelector true).
        _storeServiceMock.Setup(s => s.GetAllStores()).ReturnsAsync(new List<Store> {
            new() { Id = "store1", Shortcut = "Store 1" }
        });

        var model = new ProductModel.TierPriceModel();
        await _productViewModelService.PrepareTierPriceModel(model);

        Assert.IsTrue(model.AvailableStores.Any(x => x.Value == "store1"),
            "Admin should offer a store dropdown for tier prices.");
    }

    private void SetupSearchProducts()
    {
        _productServiceMock.Setup(p => p.SearchProducts(
                It.IsAny<bool>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<IList<string>>(),
                It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),
                It.IsAny<ProductType?>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<bool?>(), It.IsAny<bool?>(),
                It.IsAny<double?>(), It.IsAny<double?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>(),
                It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<string>(), It.IsAny<IList<string>>(), It.IsAny<IList<string>>(),
                It.IsAny<ProductSortingEnum>(), It.IsAny<bool>(), It.IsAny<bool?>()))
            .ReturnsAsync((new PagedList<Product>(), new List<string>()));
    }

    private void VerifySearchProductsCalledWithVendorId(string expectedVendorId)
    {
        _productServiceMock.Verify(p => p.SearchProducts(
            It.IsAny<bool>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<IList<string>>(),
            It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), expectedVendorId, It.IsAny<string>(),
            It.IsAny<ProductType?>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<bool?>(), It.IsAny<bool?>(),
            It.IsAny<double?>(), It.IsAny<double?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>(),
            It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<string>(), It.IsAny<IList<string>>(), It.IsAny<IList<string>>(),
            It.IsAny<ProductSortingEnum>(), It.IsAny<bool>(), It.IsAny<bool?>()), Times.Once);
    }

    [TestMethod]
    public async Task PrepareBulkEditProductModel_VendorScope_ForcesVendorFilter()
    {
        _scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor1");
        SetupSearchProducts();

        await _productViewModelService.PrepareBulkEditProductModel(new BulkEditListModel(), 1, 10);

        VerifySearchProductsCalledWithVendorId("vendor1");
    }

    [TestMethod]
    public async Task PrepareBulkEditProductModel_GlobalScope_DoesNotFilterByVendor()
    {
        // Default Setup() scope: Admin's Global scope (DefaultVendorId null).
        SetupSearchProducts();

        await _productViewModelService.PrepareBulkEditProductModel(new BulkEditListModel(), 1, 10);

        VerifySearchProductsCalledWithVendorId("");
    }

    [TestMethod]
    public async Task InsertBulkEdit_StoreScope_CreatesSimpleProductInTheStore()
    {
        _scopeMock.Setup(s => s.DefaultStoreId).Returns("store1");
        Product inserted = null;
        _productServiceMock.Setup(p => p.InsertProduct(It.IsAny<Product>()))
            .Callback<Product>(p =>
            {
                p.Id = "new1";
                inserted = p;
            })
            .Returns(Task.CompletedTask);

        await _productViewModelService.InsertBulkEdit([
            new BulkEditProductModel { Id = "", Name = " Quick one ", Sku = "Q1", Price = 9.5, Published = true },
            new BulkEditProductModel { Id = "", Name = "  " }
        ]);

        _productServiceMock.Verify(p => p.InsertProduct(It.IsAny<Product>()), Times.Once);
        Assert.IsNotNull(inserted);
        Assert.AreEqual("Quick one", inserted.Name);
        Assert.AreEqual("Q1", inserted.Sku);
        Assert.AreEqual(9.5, inserted.Price);
        Assert.AreEqual(ProductType.SimpleProduct, inserted.ProductTypeId);
        Assert.IsTrue(inserted.VisibleIndividually);
        CollectionAssert.AreEqual(new[] { "store1" }, inserted.Stores.ToArray());
    }

    [TestMethod]
    public async Task PrepareProductsModel_VendorScope_OverridesModelVendorId()
    {
        _scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor1");
        SetupSearchProducts();

        var model = new ProductListModel { SearchVendorId = "vendor2" };
        await _productViewModelService.PrepareProductsModel(model, 1, 10);

        VerifySearchProductsCalledWithVendorId("vendor1");
    }

    [TestMethod]
    public async Task PrepareProductsModel_GlobalScope_UsesModelVendorId()
    {
        // Default Setup() scope: Admin's Global scope (DefaultVendorId null).
        SetupSearchProducts();

        var model = new ProductListModel { SearchVendorId = "vendor2" };
        await _productViewModelService.PrepareProductsModel(model, 1, 10);

        VerifySearchProductsCalledWithVendorId("vendor2");
    }

    [TestMethod]
    public async Task PrepareProducts_VendorScope_OverridesModelVendorId()
    {
        _scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor1");
        SetupSearchProducts();

        var model = new ProductListModel { SearchVendorId = "vendor2" };
        await _productViewModelService.PrepareProducts(model);

        VerifySearchProductsCalledWithVendorId("vendor1");
    }

    [TestMethod]
    public async Task PrepareProductModel_AddProductModel_VendorScope_OverridesModelVendorId()
    {
        _scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor1");
        SetupSearchProducts();

        var model = new ProductModel.AddRelatedProductModel { SearchVendorId = "vendor2" };
        await _productViewModelService.PrepareProductModel(model, 1, 10);

        VerifySearchProductsCalledWithVendorId("vendor1");
    }

    [TestMethod]
    public async Task PrepareRelatedProductModel_VendorScope_HidesVendorDropdown()
    {
        _scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor1");

        var model = await _productViewModelService.PrepareRelatedProductModel();

        Assert.IsFalse(model.AvailableVendors.Any(),
            "Vendor's original PrepareAddProductModel<T> never populated a vendor picker - the search is always forced to the current vendor.");
        _vendorServiceMock.Verify(v => v.GetAllVendors(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<bool>()),
            Times.Never);
    }

    [TestMethod]
    public async Task PrepareRelatedProductModel_GlobalScope_IncludesVendorDropdown()
    {
        // Default Setup() scope: Admin's Global scope (DefaultVendorId null).
        _vendorServiceMock.Setup(v => v.GetAllVendors(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>(), true))
            .ReturnsAsync(new PagedList<Vendor> { new() { Id = "vendor1", Name = "Vendor 1" } });

        var model = await _productViewModelService.PrepareRelatedProductModel();

        Assert.IsTrue(model.AvailableVendors.Any(x => x.Value == "vendor1"),
            "Admin/Store should keep offering a vendor picker.");
    }

    [TestMethod]
    public async Task InsertProductModel_VendorScope_ForcesVendorId()
    {
        _scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor1");
        var model = new ProductModel { Name = "Test product" };

        var product = await _productViewModelService.InsertProductModel(model);

        Assert.AreEqual("vendor1", product.VendorId,
            "Vendor's original InsertProductModel always set product.VendorId = CurrentVendor.Id - without " +
            "this, a vendor-created product would map whatever (usually blank) VendorId the model carries " +
            "and end up orphaned, inaccessible to the vendor who just created it.");
    }

    [TestMethod]
    public async Task InsertProductModel_GlobalScope_DoesNotForceVendorId()
    {
        // Default Setup() scope: Admin's Global scope (DefaultVendorId null).
        var model = new ProductModel { Name = "Test product", VendorId = "vendor2" };

        var product = await _productViewModelService.InsertProductModel(model);

        Assert.AreEqual("vendor2", product.VendorId,
            "Admin/Store should keep whatever vendor ownership the create form assigns.");
    }

    [TestMethod]
    public async Task UpdateProductModel_VendorScope_ForcesVendorId_PreventsCrossVendorReassignment()
    {
        _scopeMock.Setup(s => s.DefaultVendorId).Returns("vendor1");
        var product = new Product { Id = "p1", VendorId = "vendor1" };
        var model = new ProductModel { Id = "p1", VendorId = "vendor-attacker-supplied" };

        var result = await _productViewModelService.UpdateProductModel(product, model);

        Assert.AreEqual("vendor1", result.VendorId,
            "AdminShared's shared ProductProfile does not ignore ProductModel.VendorId -> Product.VendorId " +
            "(Admin's edit form legitimately reassigns vendor ownership); without re-forcing it after mapping, " +
            "a vendor could reassign their own product to a different vendor id via a tampered VendorId field.");
    }

    [TestMethod]
    public async Task UpdateProductModel_GlobalScope_UsesModelVendorId()
    {
        // Default Setup() scope: Admin's Global scope (DefaultVendorId null).
        var product = new Product { Id = "p1", VendorId = "vendor1" };
        var model = new ProductModel { Id = "p1", VendorId = "vendor2" };

        var result = await _productViewModelService.UpdateProductModel(product, model);

        Assert.AreEqual("vendor2", result.VendorId,
            "Admin should keep being able to reassign a product's vendor ownership via the edit form.");
    }

    private void SetupOwnershipForInsertTests(Product ownedProduct, Product notOwnedProduct)
    {
        _productServiceMock.Setup(p => p.GetProductById(ownedProduct.Id, It.IsAny<bool>())).ReturnsAsync(ownedProduct);
        _productServiceMock.Setup(p => p.GetProductById(notOwnedProduct.Id, It.IsAny<bool>())).ReturnsAsync(notOwnedProduct);
        _scopeMock.Setup(s => s.HasAccess(ownedProduct)).ReturnsAsync(true);
        _scopeMock.Setup(s => s.HasAccess(notOwnedProduct)).ReturnsAsync(false);
    }

    [TestMethod]
    public async Task InsertRelatedProductModel_DropsNotOwnedSelectedId()
    {
        var mainProduct = new Product { Id = "main" };
        var owned = new Product { Id = "owned" };
        var notOwned = new Product { Id = "not-owned" };
        _productServiceMock.Setup(p => p.GetProductById("main", It.IsAny<bool>())).ReturnsAsync(mainProduct);
        SetupOwnershipForInsertTests(owned, notOwned);

        var model = new ProductModel.AddRelatedProductModel {
            ProductId = "main",
            SelectedProductIds = ["owned", "not-owned"]
        };
        await _productViewModelService.InsertRelatedProductModel(model);

        Assert.IsTrue(mainProduct.RelatedProducts.Any(x => x.ProductId2 == "owned"),
            "The owned selected product should be inserted.");
        Assert.IsFalse(mainProduct.RelatedProducts.Any(x => x.ProductId2 == "not-owned"),
            "A not-owned selected product must be silently dropped, not inserted.");
        _productServiceMock.Verify(p => p.InsertRelatedProduct(It.Is<RelatedProduct>(r => r.ProductId2 == "not-owned"), It.IsAny<string>()), Times.Never);
    }

    [TestMethod]
    public async Task InsertSimilarProductModel_DropsNotOwnedSelectedId()
    {
        var mainProduct = new Product { Id = "main" };
        var owned = new Product { Id = "owned" };
        var notOwned = new Product { Id = "not-owned" };
        _productServiceMock.Setup(p => p.GetProductById("main", It.IsAny<bool>())).ReturnsAsync(mainProduct);
        SetupOwnershipForInsertTests(owned, notOwned);

        var model = new ProductModel.AddSimilarProductModel {
            ProductId = "main",
            SelectedProductIds = ["owned", "not-owned"]
        };
        await _productViewModelService.InsertSimilarProductModel(model);

        Assert.IsTrue(mainProduct.SimilarProducts.Any(x => x.ProductId2 == "owned"),
            "The owned selected product should be inserted.");
        Assert.IsFalse(mainProduct.SimilarProducts.Any(x => x.ProductId2 == "not-owned"),
            "A not-owned selected product must be silently dropped, not inserted.");
        _productServiceMock.Verify(p => p.InsertSimilarProduct(It.Is<SimilarProduct>(r => r.ProductId2 == "not-owned")), Times.Never);
    }

    [TestMethod]
    public async Task InsertBundleProductModel_DropsNotOwnedSelectedId()
    {
        var mainProduct = new Product { Id = "main" };
        var owned = new Product { Id = "owned" };
        var notOwned = new Product { Id = "not-owned" };
        _productServiceMock.Setup(p => p.GetProductById("main", It.IsAny<bool>())).ReturnsAsync(mainProduct);
        SetupOwnershipForInsertTests(owned, notOwned);

        var model = new ProductModel.AddBundleProductModel {
            ProductId = "main",
            SelectedProductIds = ["owned", "not-owned"]
        };
        await _productViewModelService.InsertBundleProductModel(model);

        Assert.IsTrue(mainProduct.BundleProducts.Any(x => x.ProductId == "owned"),
            "The owned selected product should be inserted.");
        Assert.IsFalse(mainProduct.BundleProducts.Any(x => x.ProductId == "not-owned"),
            "A not-owned selected product must be silently dropped, not inserted.");
        _productServiceMock.Verify(p => p.InsertBundleProduct(It.Is<BundleProduct>(r => r.ProductId == "not-owned"), It.IsAny<string>()), Times.Never);
    }

    [TestMethod]
    public async Task InsertCrossSellProductModel_DropsNotOwnedSelectedId()
    {
        var mainProduct = new Product { Id = "main" };
        var owned = new Product { Id = "owned" };
        var notOwned = new Product { Id = "not-owned" };
        _productServiceMock.Setup(p => p.GetProductById("main", It.IsAny<bool>())).ReturnsAsync(mainProduct);
        SetupOwnershipForInsertTests(owned, notOwned);

        var model = new ProductModel.AddCrossSellProductModel {
            ProductId = "main",
            SelectedProductIds = ["owned", "not-owned"]
        };
        await _productViewModelService.InsertCrossSellProductModel(model);

        _productServiceMock.Verify(p => p.InsertCrossSellProduct(It.Is<CrossSellProduct>(r => r.ProductId2 == "owned")), Times.Once);
        _productServiceMock.Verify(p => p.InsertCrossSellProduct(It.Is<CrossSellProduct>(r => r.ProductId2 == "not-owned")), Times.Never,
            "A not-owned selected product must be silently dropped, not inserted.");
    }

    [TestMethod]
    public async Task InsertRecommendedProductModel_DropsNotOwnedSelectedId()
    {
        var mainProduct = new Product { Id = "main" };
        var owned = new Product { Id = "owned" };
        var notOwned = new Product { Id = "not-owned" };
        _productServiceMock.Setup(p => p.GetProductById("main", It.IsAny<bool>())).ReturnsAsync(mainProduct);
        SetupOwnershipForInsertTests(owned, notOwned);

        var model = new ProductModel.AddRecommendedProductModel {
            ProductId = "main",
            SelectedProductIds = ["owned", "not-owned"]
        };
        await _productViewModelService.InsertRecommendedProductModel(model);

        _productServiceMock.Verify(p => p.InsertRecommendedProduct("main", "owned"), Times.Once);
        _productServiceMock.Verify(p => p.InsertRecommendedProduct("main", "not-owned"), Times.Never,
            "A not-owned selected product must be silently dropped, not inserted.");
    }
}