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.Common.Localization;
using Grand.Business.Core.Interfaces.Messages;
using Grand.Business.Core.Interfaces.Storage;
using Grand.Domain;
using Grand.Domain.Messages;
using Grand.Infrastructure.Mapper;
using Grand.Mapping;
using Grand.Web.AdminShared.Controllers;
using Grand.Web.AdminShared.Interfaces;
using Grand.Web.AdminShared.Mapper;
using Grand.Web.AdminShared.Models.Messages;
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 BaseMessageTemplateControllerTests
{
private Mock<IMessageTemplateService> _messageTemplateService;
private Mock<IEmailAccountService> _emailAccountService;
private Mock<ILanguageService> _languageService;
private Mock<ITranslationService> _translationService;
private Mock<IMessageTokenProvider> _messageTokenProvider;
private Mock<IDownloadService> _downloadService;
private Mock<IAdminDataScope<MessageTemplate>> _scope;
private EmailAccountSettings _emailAccountSettings;
private class TestableMessageTemplateController(
IMessageTemplateService messageTemplateService,
IEmailAccountService emailAccountService,
ILanguageService languageService,
ITranslationService translationService,
IMessageTokenProvider messageTokenProvider,
IDownloadService downloadService,
IAdminDataScope<MessageTemplate> scope,
EmailAccountSettings emailAccountSettings)
: BaseMessageTemplateController(messageTemplateService, emailAccountService, languageService,
translationService, messageTokenProvider, downloadService, scope, emailAccountSettings);
private TestableMessageTemplateController CreateController()
{
var controller = new TestableMessageTemplateController(_messageTemplateService.Object, _emailAccountService.Object,
_languageService.Object, _translationService.Object, _messageTokenProvider.Object, _downloadService.Object,
_scope.Object, _emailAccountSettings);
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);
return controller;
}
[TestInitialize]
public void Setup()
{
var mapperConfig = new MapperConfiguration(cfg => cfg.AddProfile<MessageTemplateProfile>());
AutoMapperConfig.Init(mapperConfig);
_messageTemplateService = new Mock<IMessageTemplateService>();
_emailAccountService = new Mock<IEmailAccountService>();
_languageService = new Mock<ILanguageService>();
_translationService = new Mock<ITranslationService>();
_messageTokenProvider = new Mock<IMessageTokenProvider>();
_downloadService = new Mock<IDownloadService>();
_scope = new Mock<IAdminDataScope<MessageTemplate>>();
_emailAccountSettings = new EmailAccountSettings { DefaultEmailAccountId = "default-ea" };
_messageTokenProvider.Setup(s => s.GetListOfAllowedTokens()).Returns(Array.Empty<string>());
_emailAccountService.Setup(s => s.GetAllEmailAccounts(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>()))
.ReturnsAsync(new PagedList<Grand.Domain.Messages.EmailAccount>(new List<Grand.Domain.Messages.EmailAccount>(), 0, int.MaxValue));
_translationService.Setup(s => s.GetResource(It.IsAny<string>())).Returns((string k) => k);
_languageService.Setup(s => s.GetAllLanguages(It.IsAny<bool>(), It.IsAny<string>())).ReturnsAsync(new List<Grand.Domain.Localization.Language>());
}
[TestMethod]
public async Task EditGet_NotFound_RedirectsToList()
{
_messageTemplateService.Setup(s => s.GetMessageTemplateById("missing")).ReturnsAsync((MessageTemplate)null);
var result = await CreateController().Edit("missing") as RedirectToActionResult;
Assert.IsNotNull(result);
Assert.AreEqual("List", result.ActionName);
}
[TestMethod]
public async Task EditGet_CanViewFalse_RedirectsToList()
{
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = true, Stores = ["store-2"] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.CanView(template)).ReturnsAsync(false);
var result = await CreateController().Edit("mt-1") as RedirectToActionResult;
Assert.IsNotNull(result);
Assert.AreEqual("List", result.ActionName);
}
[TestMethod]
public async Task EditGet_GlobalTemplate_Store_IsReadOnlyTrue_CanCopyTrue()
{
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = false, Stores = [] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.CanView(template)).ReturnsAsync(true);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(false);
_scope.Setup(s => s.DefaultStoreId).Returns("store-1");
var result = await CreateController().Edit("mt-1") as ViewResult;
var model = result?.Model as MessageTemplateModel;
Assert.IsNotNull(model);
Assert.IsTrue(model.IsReadOnly);
Assert.IsTrue(model.CanCopy);
}
[TestMethod]
public async Task EditGet_OwnStoreTemplate_Store_IsReadOnlyFalse_CanCopyFalse()
{
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = true, Stores = ["store-1"] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.CanView(template)).ReturnsAsync(true);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(true);
_scope.Setup(s => s.DefaultStoreId).Returns("store-1");
var result = await CreateController().Edit("mt-1") as ViewResult;
var model = result?.Model as MessageTemplateModel;
Assert.IsNotNull(model);
Assert.IsFalse(model.IsReadOnly);
Assert.IsFalse(model.CanCopy);
}
[TestMethod]
public async Task EditGet_OtherStoreSharedTemplate_Store_IsReadOnlyTrue_CanCopyFalse()
{
// Regression test alongside CopyTemplate_Store_OtherStoreExclusiveTemplate_Denied: a
// template shared with (or exclusively owned by) a DIFFERENT store has HasAccess ==
// false, same as a fully global template — but unlike global, it must NOT be
// copyable. CanView allows opening it read-only (multi-store-shared case), but
// CanCopy must stay false since CopyTemplate itself denies it server-side.
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = true, Stores = ["store-1", "store-2"] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.CanView(template)).ReturnsAsync(true);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(false);
_scope.Setup(s => s.DefaultStoreId).Returns("store-3");
var result = await CreateController().Edit("mt-1") as ViewResult;
var model = result?.Model as MessageTemplateModel;
Assert.IsNotNull(model);
Assert.IsTrue(model.IsReadOnly);
Assert.IsFalse(model.CanCopy);
}
[TestMethod]
public async Task EditGet_Admin_AlwaysNotReadOnly_AlwaysCanCopy()
{
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = true, Stores = ["store-2"] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.CanView(template)).ReturnsAsync(true);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(true);
_scope.Setup(s => s.DefaultStoreId).Returns((string)null);
var result = await CreateController().Edit("mt-1") as ViewResult;
var model = result?.Model as MessageTemplateModel;
Assert.IsNotNull(model);
Assert.IsFalse(model.IsReadOnly);
Assert.IsTrue(model.CanCopy);
}
[TestMethod]
public async Task EditGet_Admin_EmptyLocaleEmailAccountId_FallsBackToDefaultEmailAccount()
{
// Regression test restoring Admin's original Edit(GET) fallback (6deba9db9), dropped
// silently by the consolidation: when a language has no per-language EmailAccountId
// translation, Admin must preselect EmailAccountSettings.DefaultEmailAccountId rather
// than leaving the dropdown empty.
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = false, Stores = [] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.CanView(template)).ReturnsAsync(true);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(true);
_scope.Setup(s => s.DefaultStoreId).Returns((string)null);
_languageService.Setup(s => s.GetAllLanguages(It.IsAny<bool>(), It.IsAny<string>()))
.ReturnsAsync(new List<Grand.Domain.Localization.Language> { new() { Id = "lang-1" } });
var result = await CreateController().Edit("mt-1") as ViewResult;
var model = result?.Model as MessageTemplateModel;
Assert.IsNotNull(model);
Assert.AreEqual(1, model.Locales.Count);
Assert.AreEqual("default-ea", model.Locales[0].EmailAccountId);
}
[TestMethod]
public async Task EditGet_Store_EmptyLocaleEmailAccountId_StaysEmpty_NoFallback()
{
// Store's original Edit(GET) never had the default-email-account fallback; the fix
// for the Admin regression must not introduce it for Store.
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = true, Stores = ["store-1"] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.CanView(template)).ReturnsAsync(true);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(true);
_scope.Setup(s => s.DefaultStoreId).Returns("store-1");
_languageService.Setup(s => s.GetAllLanguages(It.IsAny<bool>(), It.IsAny<string>()))
.ReturnsAsync(new List<Grand.Domain.Localization.Language> { new() { Id = "lang-1" } });
var result = await CreateController().Edit("mt-1") as ViewResult;
var model = result?.Model as MessageTemplateModel;
Assert.IsNotNull(model);
Assert.AreEqual(1, model.Locales.Count);
Assert.IsTrue(string.IsNullOrEmpty(model.Locales[0].EmailAccountId));
}
[TestMethod]
public async Task EditPost_HasAccessFalse_RedirectsToListWithoutSaving()
{
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = true, Stores = ["store-2"] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(false);
var result = await CreateController().Edit(new MessageTemplateModel { Id = "mt-1" }, false) as RedirectToActionResult;
Assert.IsNotNull(result);
Assert.AreEqual("List", result.ActionName);
_messageTemplateService.Verify(s => s.UpdateMessageTemplate(It.IsAny<MessageTemplate>()), Times.Never);
}
[TestMethod]
public async Task EditPost_Store_ForcesLimitedToStoresRegardlessOfSubmittedModel()
{
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = true, Stores = ["store-1"], Name = "N" };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(true);
_scope.Setup(s => s.DefaultStoreId).Returns("store-1");
MessageTemplate saved = null;
_messageTemplateService.Setup(s => s.UpdateMessageTemplate(It.IsAny<MessageTemplate>()))
.Callback<MessageTemplate>(t => saved = t)
.Returns(Task.CompletedTask);
var model = new MessageTemplateModel { Id = "mt-1", Name = "N", Stores = [] };
await CreateController().Edit(model, false);
Assert.IsNotNull(saved);
Assert.IsTrue(saved.LimitedToStores);
CollectionAssert.AreEqual(new[] { "store-1" }, saved.Stores.ToArray());
}
[TestMethod]
public async Task EditPost_Admin_DoesNotForceLimitedToStores()
{
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = false, Stores = [], Name = "N" };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(true);
_scope.Setup(s => s.DefaultStoreId).Returns((string)null);
MessageTemplate saved = null;
_messageTemplateService.Setup(s => s.UpdateMessageTemplate(It.IsAny<MessageTemplate>()))
.Callback<MessageTemplate>(t => saved = t)
.Returns(Task.CompletedTask);
var model = new MessageTemplateModel { Id = "mt-1", Name = "N" };
await CreateController().Edit(model, false);
Assert.IsNotNull(saved);
Assert.IsFalse(saved.LimitedToStores);
}
[TestMethod]
public async Task Delete_HasAccessFalse_DoesNotDelete()
{
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = true, Stores = ["store-2"] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(false);
var result = await CreateController().Delete("mt-1") as RedirectToActionResult;
Assert.IsNotNull(result);
Assert.AreEqual("List", result.ActionName);
_messageTemplateService.Verify(s => s.DeleteMessageTemplate(It.IsAny<MessageTemplate>()), Times.Never);
}
[TestMethod]
public async Task Delete_HasAccessTrue_Deletes()
{
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = true, Stores = ["store-1"] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(true);
var result = await CreateController().Delete("mt-1") as RedirectToActionResult;
Assert.IsNotNull(result);
Assert.AreEqual("List", result.ActionName);
_messageTemplateService.Verify(s => s.DeleteMessageTemplate(template), Times.Once);
}
[TestMethod]
public async Task CopyTemplate_Store_OwnTemplate_Denied()
{
var template = new MessageTemplate { Id = "mt-1", LimitedToStores = true, Stores = ["store-1"] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.DefaultStoreId).Returns("store-1");
var result = await CreateController().CopyTemplate(new MessageTemplateModel { Id = "mt-1" }) as RedirectToActionResult;
Assert.IsNotNull(result);
Assert.AreEqual("List", result.ActionName);
_messageTemplateService.Verify(s => s.CopyMessageTemplate(It.IsAny<MessageTemplate>()), Times.Never);
}
[TestMethod]
public async Task CopyTemplate_Store_OtherStoreExclusiveTemplate_Denied()
{
// Regression test for a real Critical found via live smoke test: a template owned
// exclusively by ANOTHER store (HasAccess == false, but also LimitedToStores == true)
// must be denied, not copied. The bug: an earlier version of the guard checked
// scope.HasAccess(messageTemplate) instead of messageTemplate.LimitedToStores, which
// let store1 successfully copy store2's exclusive template's content.
var template = new MessageTemplate { Id = "mt-1", Name = "N", LimitedToStores = true, Stores = ["store-2"] };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(false);
_scope.Setup(s => s.DefaultStoreId).Returns("store-1");
var result = await CreateController().CopyTemplate(new MessageTemplateModel { Id = "mt-1" }) as RedirectToActionResult;
Assert.IsNotNull(result);
Assert.AreEqual("List", result.ActionName);
_messageTemplateService.Verify(s => s.CopyMessageTemplate(It.IsAny<MessageTemplate>()), Times.Never);
}
[TestMethod]
public async Task CopyTemplate_Store_GlobalTemplate_CopiesAndAssignsToCurrentStore()
{
var template = new MessageTemplate { Id = "mt-1", Name = "N", LimitedToStores = false, Stores = [] };
var copy = new MessageTemplate { Id = "mt-2", Name = "N" };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.HasAccess(template)).ReturnsAsync(false);
_scope.Setup(s => s.DefaultStoreId).Returns("store-1");
_messageTemplateService.Setup(s => s.GetAllMessageTemplates("", "N", 0, int.MaxValue)).ReturnsAsync(new PagedList<MessageTemplate>(new List<MessageTemplate>(), 0, int.MaxValue));
_messageTemplateService.Setup(s => s.CopyMessageTemplate(template)).ReturnsAsync(copy);
MessageTemplate updated = null;
_messageTemplateService.Setup(s => s.UpdateMessageTemplate(It.IsAny<MessageTemplate>()))
.Callback<MessageTemplate>(t => updated = t)
.Returns(Task.CompletedTask);
var result = await CreateController().CopyTemplate(new MessageTemplateModel { Id = "mt-1" }) as RedirectToActionResult;
Assert.IsNotNull(result);
Assert.AreEqual("Edit", result.ActionName);
Assert.IsNotNull(updated);
Assert.IsTrue(updated.LimitedToStores);
CollectionAssert.AreEqual(new[] { "store-1" }, updated.Stores.ToArray());
}
[TestMethod]
public async Task CopyTemplate_Admin_Unrestricted()
{
var template = new MessageTemplate { Id = "mt-1", Name = "N", LimitedToStores = true, Stores = ["store-1"] };
var copy = new MessageTemplate { Id = "mt-2", Name = "N" };
_messageTemplateService.Setup(s => s.GetMessageTemplateById("mt-1")).ReturnsAsync(template);
_scope.Setup(s => s.DefaultStoreId).Returns((string)null);
_messageTemplateService.Setup(s => s.CopyMessageTemplate(template)).ReturnsAsync(copy);
var result = await CreateController().CopyTemplate(new MessageTemplateModel { Id = "mt-1" }) as RedirectToActionResult;
Assert.IsNotNull(result);
Assert.AreEqual("Edit", result.ActionName);
_messageTemplateService.Verify(s => s.UpdateMessageTemplate(It.IsAny<MessageTemplate>()), Times.Never);
}
}