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

supporta92f38ac04a4
diff --git a/src/Tests/Grand.Business.Cms.Tests/Grand.Business.Cms.Tests.csproj b/src/Tests/Grand.Business.Cms.Tests/Grand.Business.Cms.Tests.csproj
index 94f6ddda8..95938aa13 100644
--- a/src/Tests/Grand.Business.Cms.Tests/Grand.Business.Cms.Tests.csproj
+++ b/src/Tests/Grand.Business.Cms.Tests/Grand.Business.Cms.Tests.csproj
@@ -17,7 +17,10 @@
<ItemGroup>
<ProjectReference Include="..\..\Business\Grand.Business.Cms\Grand.Business.Cms.csproj" />
+ <ProjectReference Include="..\..\Business\Grand.Business.Common\Grand.Business.Common.csproj" />
<ProjectReference Include="..\..\Business\Grand.Business.Core\Grand.Business.Core.csproj" />
+ <ProjectReference Include="..\Grand.Data.Tests\Grand.Data.Tests.csproj" />
+ <ProjectReference Include="..\Grand.Infrastructure.Tests\Grand.Infrastructure.Tests.csproj" />
</ItemGroup>
</Project>
diff --git a/src/Tests/Grand.Business.Cms.Tests/Services/KnowledgebaseServiceTests.cs b/src/Tests/Grand.Business.Cms.Tests/Services/KnowledgebaseServiceTests.cs
new file mode 100644
index 000000000..e9537e4de
--- /dev/null
+++ b/src/Tests/Grand.Business.Cms.Tests/Services/KnowledgebaseServiceTests.cs
@@ -0,0 +1,374 @@
+using Grand.Data.Tests.MongoDb;
+using Grand.Domain.Customers;
+using Grand.Domain.Data;
+using Grand.Domain.Knowledgebase;
+using Grand.Infrastructure;
+using Grand.Infrastructure.Caching;
+using Grand.Infrastructure.Tests.Caching;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Cms.Services.Tests
+{
+ [TestClass()]
+ public class KnowledgebaseServiceTests
+ {
+
+ private KnowledgebaseService _knowledgebaseService;
+
+ private IRepository<KnowledgebaseCategory> _repositoryKnowledgebaseCategory;
+ private IRepository<KnowledgebaseArticle> _repositoryKnowledgebaseArticle;
+ private IRepository<KnowledgebaseArticleComment> _repositoryKnowledgebaseArticleComment;
+ private Mock<IWorkContext> _workContextMock;
+ private Mock<IMediator> _mediatorMock;
+ private MemoryCacheBase _cacheBase;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _repositoryKnowledgebaseCategory = new MongoDBRepositoryTest<KnowledgebaseCategory>();
+ _repositoryKnowledgebaseArticle = new MongoDBRepositoryTest<KnowledgebaseArticle>();
+ _repositoryKnowledgebaseArticleComment = new MongoDBRepositoryTest<KnowledgebaseArticleComment>();
+
+ _mediatorMock = new Mock<IMediator>();
+ _workContextMock = new Mock<IWorkContext>();
+
+ _workContextMock.Setup(c => c.CurrentStore).Returns(() => new Domain.Stores.Store() { Id = "", Name = "test store" });
+ _workContextMock.Setup(c => c.CurrentCustomer).Returns(() => new Customer());
+
+ _cacheBase = new MemoryCacheBase(MemoryCacheTest.Get(), _mediatorMock.Object);
+ _knowledgebaseService = new KnowledgebaseService(_repositoryKnowledgebaseCategory, _repositoryKnowledgebaseArticle, _repositoryKnowledgebaseArticleComment, _mediatorMock.Object,
+ _workContextMock.Object, _cacheBase);
+ }
+
+ [TestMethod()]
+ public async Task DeleteKnowledgebaseCategoryTest()
+ {
+ //Arrange
+ var knowledgebaseCategory = new KnowledgebaseCategory();
+ await _repositoryKnowledgebaseCategory.InsertAsync(knowledgebaseCategory);
+ //Act
+ await _knowledgebaseService.DeleteKnowledgebaseCategory(knowledgebaseCategory);
+ //Assert
+ Assert.IsFalse(_repositoryKnowledgebaseCategory.Table.Any());
+
+ }
+
+ [TestMethod()]
+ public async Task UpdateKnowledgebaseCategoryTest()
+ {
+ //Arrange
+ var knowledgebaseCategory = new KnowledgebaseCategory();
+ await _repositoryKnowledgebaseCategory.InsertAsync(knowledgebaseCategory);
+ //Act
+ knowledgebaseCategory.Name = "test";
+ await _knowledgebaseService.UpdateKnowledgebaseCategory(knowledgebaseCategory);
+ //Assert
+ Assert.IsTrue(_repositoryKnowledgebaseCategory.Table.FirstOrDefault(x => x.Id == knowledgebaseCategory.Id).Name == "test");
+ }
+
+ [TestMethod()]
+ public async Task GetKnowledgebaseCategoryTest()
+ {
+ //Arrange
+ var knowledgebaseCategory = new KnowledgebaseCategory();
+ await _repositoryKnowledgebaseCategory.InsertAsync(knowledgebaseCategory);
+ //Act
+ var result = await _knowledgebaseService.GetKnowledgebaseCategory(knowledgebaseCategory.Id);
+ //Assert
+ Assert.IsNotNull(result);
+ }
+
+ [TestMethod()]
+ public async Task GetPublicKnowledgebaseCategoryTest()
+ {
+ //Arrange
+ var knowledgebaseCategory = new KnowledgebaseCategory() { Published = true };
+ await _repositoryKnowledgebaseCategory.InsertAsync(knowledgebaseCategory);
+ //Act
+ var result = await _knowledgebaseService.GetPublicKnowledgebaseCategory(knowledgebaseCategory.Id);
+ //Assert
+ Assert.IsNotNull(result);
+ }
+
+ [TestMethod()]
+ public async Task InsertKnowledgebaseCategoryTest()
+ {
+ //Arrange
+ var knowledgebaseCategory = new KnowledgebaseCategory();
+ //Act
+ await _knowledgebaseService.InsertKnowledgebaseCategory(knowledgebaseCategory);
+ var result = await _knowledgebaseService.GetKnowledgebaseCategory(knowledgebaseCategory.Id);
+ //Assert
+ Assert.IsNotNull(result);
+ }
+
+ [TestMethod()]
+ public async Task GetKnowledgebaseCategoriesTest()
+ {
+ //Arrange
+ var knowledgebaseCategory = new KnowledgebaseCategory() { Published = true };
+ await _repositoryKnowledgebaseCategory.InsertAsync(knowledgebaseCategory);
+ //Act
+ var result = await _knowledgebaseService.GetKnowledgebaseCategories();
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetKnowledgebaseArticleTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true };
+ await _repositoryKnowledgebaseArticle.InsertAsync(knowledgebaseArticle);
+ //Act
+ var result = await _knowledgebaseService.GetKnowledgebaseArticle(knowledgebaseArticle.Id);
+ //Assert
+ Assert.IsNotNull(result);
+ }
+
+ [TestMethod()]
+ public async Task GetKnowledgebaseArticlesTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true };
+ await _repositoryKnowledgebaseArticle.InsertAsync(knowledgebaseArticle);
+ //Act
+ var result = await _knowledgebaseService.GetKnowledgebaseArticles();
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task InsertKnowledgebaseArticleTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true };
+ //Act
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
+ //Assert
+ Assert.IsTrue(_repositoryKnowledgebaseArticle.Table.Any());
+ }
+
+ [TestMethod()]
+ public async Task UpdateKnowledgebaseArticleTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true };
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
+ //Act
+ knowledgebaseArticle.Name = "test";
+ await _knowledgebaseService.UpdateKnowledgebaseArticle(knowledgebaseArticle);
+ //Assert
+ Assert.IsTrue(_repositoryKnowledgebaseArticle.Table.FirstOrDefault(x => x.Id == knowledgebaseArticle.Id).Name == "test");
+ }
+
+ [TestMethod()]
+ public async Task DeleteKnowledgebaseArticleTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true };
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
+ //Act
+ await _knowledgebaseService.DeleteKnowledgebaseArticle(knowledgebaseArticle);
+ //Assert
+ Assert.IsNull(_repositoryKnowledgebaseArticle.Table.FirstOrDefault(x => x.Id == knowledgebaseArticle.Id));
+ }
+
+ [TestMethod()]
+ public async Task GetKnowledgebaseArticlesByCategoryIdTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true, ParentCategoryId = "1" };
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
+ //Act
+ var result = await _knowledgebaseService.GetKnowledgebaseArticlesByCategoryId("1");
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetPublicKnowledgebaseCategoriesTest()
+ {
+ //Arrange
+ var knowledgebaseCategory = new KnowledgebaseCategory() { Published = true };
+ await _repositoryKnowledgebaseCategory.InsertAsync(knowledgebaseCategory);
+ //Act
+ var result = await _knowledgebaseService.GetPublicKnowledgebaseCategories();
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetPublicKnowledgebaseArticlesTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true };
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
+ //Act
+ var result = await _knowledgebaseService.GetPublicKnowledgebaseArticles();
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetPublicKnowledgebaseArticleTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true };
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
+ //Act
+ var result = await _knowledgebaseService.GetPublicKnowledgebaseArticle(knowledgebaseArticle.Id);
+ //Assert
+ Assert.IsNotNull(result);
+ }
+
+ [TestMethod()]
+ public async Task GetPublicKnowledgebaseArticlesByCategoryTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true, ParentCategoryId = "1" };
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
+ //Act
+ var result = await _knowledgebaseService.GetPublicKnowledgebaseArticlesByCategory(knowledgebaseArticle.ParentCategoryId);
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetPublicKnowledgebaseArticlesByKeywordTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true, Name = "test" };
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
+ //Act
+ var result = await _knowledgebaseService.GetPublicKnowledgebaseArticlesByKeyword("test");
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetPublicKnowledgebaseCategoriesByKeywordTest()
+ {
+ //Arrange
+ var knowledgebaseCategory = new KnowledgebaseCategory() { Published = true, Name = "test" };
+ await _repositoryKnowledgebaseCategory.InsertAsync(knowledgebaseCategory);
+ //Act
+ var result = await _knowledgebaseService.GetPublicKnowledgebaseCategoriesByKeyword("test");
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetHomepageKnowledgebaseArticlesTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true, Name = "test", ShowOnHomepage = true };
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
+ //Act
+ var result = await _knowledgebaseService.GetHomepageKnowledgebaseArticles();
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetKnowledgebaseArticlesByNameTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true, Name = "test", ShowOnHomepage = true };
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
+ //Act
+ var result = await _knowledgebaseService.GetKnowledgebaseArticlesByName(knowledgebaseArticle.Name);
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetRelatedKnowledgebaseArticlesTest()
+ {
+ //Arrange
+ var knowledgebaseArticle = new KnowledgebaseArticle() { Published = true, Name = "test", ShowOnHomepage = true };
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
+ var knowledgebaseArticle1 = new KnowledgebaseArticle();
+ knowledgebaseArticle1.RelatedArticles.Add(knowledgebaseArticle.Id);
+ await _knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle1);
+ //Act
+ var result = await _knowledgebaseService.GetRelatedKnowledgebaseArticles(knowledgebaseArticle1.Id);
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task InsertArticleCommentTest()
+ {
+ //Arrange
+ var knowledgebaseArticleComment = new KnowledgebaseArticleComment();
+ //Act
+ await _knowledgebaseService.InsertArticleComment(knowledgebaseArticleComment);
+ //Assert
+ Assert.IsTrue(_repositoryKnowledgebaseArticleComment.Table.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetAllCommentsTest()
+ {
+ //Arrange
+ var knowledgebaseArticleComment = new KnowledgebaseArticleComment() { CustomerId = "1" };
+ await _knowledgebaseService.InsertArticleComment(knowledgebaseArticleComment);
+ //Act
+ var result = await _knowledgebaseService.GetAllComments("1");
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetArticleCommentByIdTest()
+ {
+ //Arrange
+ var knowledgebaseArticleComment = new KnowledgebaseArticleComment() { CustomerId = "1" };
+ await _knowledgebaseService.InsertArticleComment(knowledgebaseArticleComment);
+ //Act
+ var result = await _knowledgebaseService.GetArticleCommentById(knowledgebaseArticleComment.Id);
+ //Assert
+ Assert.IsNotNull(result);
+ }
+
+ [TestMethod()]
+ public async Task GetArticleCommentsByIdsTest()
+ {
+ //Arrange
+ var knowledgebaseArticleComment = new KnowledgebaseArticleComment() { CustomerId = "1" };
+ await _knowledgebaseService.InsertArticleComment(knowledgebaseArticleComment);
+ //Act
+ var result = await _knowledgebaseService.GetArticleCommentsByIds(new[] { knowledgebaseArticleComment.Id });
+ //Assert
+ Assert.IsTrue(result.Any());
+
+ }
+
+ [TestMethod()]
+ public async Task GetArticleCommentsByArticleIdTest()
+ {
+ //Arrange
+ var knowledgebaseArticleComment = new KnowledgebaseArticleComment() { CustomerId = "1", ArticleId = "1" };
+ await _knowledgebaseService.InsertArticleComment(knowledgebaseArticleComment);
+ //Act
+ var result = await _knowledgebaseService.GetArticleCommentsByArticleId(knowledgebaseArticleComment.ArticleId);
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task DeleteArticleCommentTest()
+ {
+ //Arrange
+ var knowledgebaseArticleComment = new KnowledgebaseArticleComment() { CustomerId = "1" };
+ await _knowledgebaseService.InsertArticleComment(knowledgebaseArticleComment);
+ //Act
+ await _knowledgebaseService.DeleteArticleComment(knowledgebaseArticleComment);
+ //Assert
+ Assert.IsNull(_repositoryKnowledgebaseArticleComment.Table.FirstOrDefault(x=>x.Id == knowledgebaseArticleComment.Id));
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Cms.Tests/Services/NewsServiceTests.cs b/src/Tests/Grand.Business.Cms.Tests/Services/NewsServiceTests.cs
new file mode 100644
index 000000000..67db01334
--- /dev/null
+++ b/src/Tests/Grand.Business.Cms.Tests/Services/NewsServiceTests.cs
@@ -0,0 +1,108 @@
+using Grand.Data.Tests.MongoDb;
+using Grand.Domain.Customers;
+using Grand.Domain.Data;
+using Grand.Domain.News;
+using Grand.Infrastructure;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Cms.Services.Tests
+{
+ [TestClass()]
+ public class NewsServiceTests
+ {
+ private NewsService _newsService;
+
+ private IRepository<NewsItem> _repository;
+ private Mock<IWorkContext> _workContextMock;
+ private Mock<IMediator> _mediatorMock;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _repository = new MongoDBRepositoryTest<NewsItem>();
+
+ _mediatorMock = new Mock<IMediator>();
+ _workContextMock = new Mock<IWorkContext>();
+
+ _workContextMock.Setup(c => c.CurrentStore).Returns(() => new Domain.Stores.Store() { Id = "", Name = "test store" });
+ _workContextMock.Setup(c => c.CurrentCustomer).Returns(() => new Customer());
+
+ _newsService = new NewsService(_repository, _mediatorMock.Object, _workContextMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task GetNewsByIdTest()
+ {
+ //Arrange
+ var newsItem = new NewsItem();
+ await _repository.InsertAsync(newsItem);
+ //Act
+ var result = await _newsService.GetNewsById(newsItem.Id);
+ //Assert
+ Assert.IsNotNull(result);
+ }
+
+ [TestMethod()]
+ public async Task GetAllNewsTest()
+ {
+ //Arrange
+ var newsItem = new NewsItem() { Published = true };
+ await _repository.InsertAsync(newsItem);
+ //Act
+ var result = await _newsService.GetAllNews();
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task InsertNewsTest()
+ {
+ //Arrange
+ var newsItem = new NewsItem();
+ //Act
+ await _newsService.InsertNews(newsItem);
+ //Assert
+ Assert.IsNotNull(_repository.Table.FirstOrDefault(x => x.Id == newsItem.Id));
+ }
+
+ [TestMethod()]
+ public async Task UpdateNewsTest()
+ {
+ //Arrange
+ var newsItem = new NewsItem() { Published = true };
+ await _repository.InsertAsync(newsItem);
+ //Act
+ newsItem.Title = "test";
+ await _newsService.UpdateNews(newsItem);
+ //Assert
+ Assert.IsTrue(_repository.Table.FirstOrDefault(x => x.Id == newsItem.Id).Title == "test");
+ }
+
+ [TestMethod()]
+ public async Task DeleteNewsTest()
+ {
+ //Arrange
+ var newsItem = new NewsItem() { Published = true };
+ await _repository.InsertAsync(newsItem);
+ //Act
+ await _newsService.DeleteNews(newsItem);
+ //Assert
+ Assert.IsNull(_repository.Table.FirstOrDefault(x => x.Id == newsItem.Id));
+ }
+
+ [TestMethod()]
+ public async Task GetAllCommentsTest()
+ {
+ //Arrange
+ var newsItem = new NewsItem() { Published = true };
+ newsItem.NewsComments.Add(new NewsComment() { CustomerId = "1" });
+ await _repository.InsertAsync(newsItem);
+ //Act
+ var result = await _newsService.GetAllComments("1");
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Cms.Tests/Services/PageLayoutServiceTests.cs b/src/Tests/Grand.Business.Cms.Tests/Services/PageLayoutServiceTests.cs
new file mode 100644
index 000000000..7de5d04ef
--- /dev/null
+++ b/src/Tests/Grand.Business.Cms.Tests/Services/PageLayoutServiceTests.cs
@@ -0,0 +1,100 @@
+using Grand.Data.Tests.MongoDb;
+using Grand.Domain.Customers;
+using Grand.Domain.Data;
+using Grand.Domain.Pages;
+using Grand.Infrastructure;
+using Grand.Infrastructure.Caching;
+using Grand.Infrastructure.Tests.Caching;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Cms.Services.Tests
+{
+ [TestClass()]
+ public class PageLayoutServiceTests
+ {
+ private PageLayoutService _pageLayoutService;
+
+ private IRepository<PageLayout> _repository;
+ private Mock<IWorkContext> _workContextMock;
+ private Mock<IMediator> _mediatorMock;
+ private MemoryCacheBase _cacheBase;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _repository = new MongoDBRepositoryTest<PageLayout>();
+
+ _mediatorMock = new Mock<IMediator>();
+ _workContextMock = new Mock<IWorkContext>();
+
+ _cacheBase = new MemoryCacheBase(MemoryCacheTest.Get(), _mediatorMock.Object);
+
+ _workContextMock.Setup(c => c.CurrentStore).Returns(() => new Domain.Stores.Store() { Id = "", Name = "test store" });
+ _workContextMock.Setup(c => c.CurrentCustomer).Returns(() => new Customer());
+
+ _pageLayoutService = new PageLayoutService(_repository, _cacheBase, _mediatorMock.Object);
+ }
+
+ [TestMethod()]
+ public async Task GetAllPageLayoutsTest()
+ {
+ //Arrange
+ var pageLayout = new PageLayout() { };
+ await _repository.InsertAsync(pageLayout);
+ //Act
+ var result = await _pageLayoutService.GetAllPageLayouts();
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task GetPageLayoutByIdTest()
+ {
+ //Arrange
+ var pageLayout = new PageLayout() { };
+ await _repository.InsertAsync(pageLayout);
+ //Act
+ var result = await _pageLayoutService.GetPageLayoutById(pageLayout.Id);
+ //Assert
+ Assert.IsNotNull(result);
+ }
+
+ [TestMethod()]
+ public async Task InsertPageLayoutTest()
+ {
+ //Arrange
+ var pageLayout = new PageLayout() { };
+ //Act
+ await _pageLayoutService.InsertPageLayout(pageLayout);
+ //Assert
+ Assert.IsNotNull(_repository.Table.FirstOrDefault(x => x.Id == pageLayout.Id));
+ }
+
+ [TestMethod()]
+ public async Task UpdatePageLayoutTest()
+ {
+ //Arrange
+ var pageLayout = new PageLayout() { };
+ await _pageLayoutService.InsertPageLayout(pageLayout);
+ //Act
+ pageLayout.Name = "test";
+ await _pageLayoutService.UpdatePageLayout(pageLayout);
+ //Assert
+ Assert.IsTrue(_repository.Table.FirstOrDefault(x => x.Id == pageLayout.Id).Name == "test");
+ }
+
+ [TestMethod()]
+ public async Task DeletePageLayoutTest()
+ {
+ //Arrange
+ var pageLayout = new PageLayout() { };
+ await _pageLayoutService.InsertPageLayout(pageLayout);
+ //Act
+ await _pageLayoutService.DeletePageLayout(pageLayout);
+ //Assert
+ Assert.IsNull(_repository.Table.FirstOrDefault(x => x.Id == pageLayout.Id));
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Cms.Tests/Services/PageServiceTests.cs b/src/Tests/Grand.Business.Cms.Tests/Services/PageServiceTests.cs
new file mode 100644
index 000000000..0d88e7c0f
--- /dev/null
+++ b/src/Tests/Grand.Business.Cms.Tests/Services/PageServiceTests.cs
@@ -0,0 +1,117 @@
+using Grand.Business.Common.Services.Security;
+using Grand.Business.Core.Interfaces.Common.Security;
+using Grand.Data.Tests.MongoDb;
+using Grand.Domain.Customers;
+using Grand.Domain.Data;
+using Grand.Domain.Pages;
+using Grand.Infrastructure;
+using Grand.Infrastructure.Caching;
+using Grand.Infrastructure.Tests.Caching;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Cms.Services.Tests
+{
+ [TestClass()]
+ public class PageServiceTests
+ {
+ private PageService _pageService;
+
+ private IRepository<Page> _repository;
+ private Mock<IWorkContext> _workContextMock;
+ private Mock<IMediator> _mediatorMock;
+ private MemoryCacheBase _cacheBase;
+ private IAclService _aclService;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _repository = new MongoDBRepositoryTest<Page>();
+
+ _mediatorMock = new Mock<IMediator>();
+ _workContextMock = new Mock<IWorkContext>();
+
+ _cacheBase = new MemoryCacheBase(MemoryCacheTest.Get(), _mediatorMock.Object);
+
+ _aclService = new AclService();
+
+ _workContextMock.Setup(c => c.CurrentStore).Returns(() => new Domain.Stores.Store() { Id = "", Name = "test store" });
+ _workContextMock.Setup(c => c.CurrentCustomer).Returns(() => new Customer());
+
+ _pageService = new PageService(_repository, _workContextMock.Object, _aclService, _mediatorMock.Object, _cacheBase);
+ }
+
+ [TestMethod()]
+ public async Task GetPageByIdTest()
+ {
+ //Arrange
+ var page = new Page() { };
+ await _repository.InsertAsync(page);
+ //Act
+ var result = await _pageService.GetPageById(page.Id);
+ //Assert
+ Assert.IsNotNull(result);
+ }
+
+ [TestMethod()]
+ public async Task GetPageBySystemNameTest()
+ {
+ //Arrange
+ var page = new Page() { SystemName = "test" };
+ await _repository.InsertAsync(page);
+ //Act
+ var result = await _pageService.GetPageBySystemName(page.SystemName);
+ //Assert
+ Assert.IsNotNull(result);
+ }
+
+ [TestMethod()]
+ public async Task GetAllPagesTest()
+ {
+ //Arrange
+ var page = new Page() { SystemName = "test", Published = true };
+ await _repository.InsertAsync(page);
+ //Act
+ var result = await _pageService.GetAllPages("");
+ //Assert
+ Assert.IsTrue(result.Any());
+ }
+
+ [TestMethod()]
+ public async Task InsertPageTest()
+ {
+ //Arrange
+ var page = new Page() { };
+ //Act
+ await _pageService.InsertPage(page);
+ //Assert
+ Assert.IsNotNull(_repository.Table.FirstOrDefault(x => x.Id == page.Id));
+ }
+
+ [TestMethod()]
+ public async Task UpdatePageTest()
+ {
+ //Arrange
+ var page = new Page() { };
+ await _pageService.InsertPage(page);
+ //Act
+ page.SystemName = "test";
+ await _pageService.UpdatePage(page);
+ //Assert
+ Assert.IsTrue(_repository.Table.FirstOrDefault(x => x.Id == page.Id).SystemName == "test");
+ }
+
+ [TestMethod()]
+ public async Task DeletePageTest()
+ {
+ //Arrange
+ var page = new Page() { };
+ await _pageService.InsertPage(page);
+ //Act
+ await _pageService.DeletePage(page);
+ //Assert
+ Assert.IsNull(_repository.Table.FirstOrDefault(x => x.Id == page.Id));
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Cms.Tests/Services/RobotsTxtServiceTests.cs b/src/Tests/Grand.Business.Cms.Tests/Services/RobotsTxtServiceTests.cs
new file mode 100644
index 000000000..eaf18b6f4
--- /dev/null
+++ b/src/Tests/Grand.Business.Cms.Tests/Services/RobotsTxtServiceTests.cs
@@ -0,0 +1,88 @@
+using Grand.Data.Tests.MongoDb;
+using Grand.Domain.Common;
+using Grand.Domain.Customers;
+using Grand.Domain.Data;
+using Grand.Infrastructure;
+using Grand.Infrastructure.Caching;
+using Grand.Infrastructure.Tests.Caching;
+using MediatR;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Business.Cms.Services.Tests
+{
+ [TestClass()]
+ public class RobotsTxtServiceTests
+ {
+ private RobotsTxtService _robotsTxtService;
+
+ private IRepository<RobotsTxt> _repository;
+ private Mock<IWorkContext> _workContextMock;
+ private Mock<IMediator> _mediatorMock;
+ private MemoryCacheBase _cacheBase;
+
+ [TestInitialize()]
+ public void Init()
+ {
+ _repository = new MongoDBRepositoryTest<RobotsTxt>();
+
+ _mediatorMock = new Mock<IMediator>();
+ _workContextMock = new Mock<IWorkContext>();
+
+ _cacheBase = new MemoryCacheBase(MemoryCacheTest.Get(), _mediatorMock.Object);
+
+ _workContextMock.Setup(c => c.CurrentStore).Returns(() => new Domain.Stores.Store() { Id = "", Name = "test store" });
+ _workContextMock.Setup(c => c.CurrentCustomer).Returns(() => new Customer());
+
+ _robotsTxtService = new RobotsTxtService(_repository, _mediatorMock.Object, _cacheBase);
+ }
+
+ [TestMethod()]
+ public async Task GetRobotsTxtTest()
+ {
+ //Arrange
+ var robotsTxt = new RobotsTxt() { StoreId = "1" };
+ await _repository.InsertAsync(robotsTxt);
+ //Act
+ var result = await _robotsTxtService.GetRobotsTxt(robotsTxt.StoreId);
+ //Assert
+ Assert.IsNotNull(result);
+ }
+
+ [TestMethod()]
+ public async Task InsertRobotsTxtTest()
+ {
+ //Arrange
+ var robotsTxt = new RobotsTxt() { StoreId = "1" };
+ //Act
+ await _robotsTxtService.InsertRobotsTxt(robotsTxt);
+ //Assert
+ Assert.IsNotNull(_repository.Table.FirstOrDefault(x => x.Id == robotsTxt.Id));
+ }
+
+ [TestMethod()]
+ public async Task UpdateRobotsTxtTest()
+ {
+ //Arrange
+ var robotsTxt = new RobotsTxt() { StoreId = "1" };
+ await _robotsTxtService.InsertRobotsTxt(robotsTxt);
+ //Act
+ robotsTxt.Text = "test";
+ await _robotsTxtService.UpdateRobotsTxt(robotsTxt);
+ //Assert
+ Assert.IsTrue(_repository.Table.FirstOrDefault(x => x.Id == robotsTxt.Id).Text == "test");
+ }
+
+ [TestMethod()]
+ public async Task DeleteRobotsTxtTest()
+ {
+ //Arrange
+ var robotsTxt = new RobotsTxt() { StoreId = "1" };
+ await _robotsTxtService.InsertRobotsTxt(robotsTxt);
+ //Act
+ await _robotsTxtService.DeleteRobotsTxt(robotsTxt);
+ //Assert
+ Assert.IsNull(_repository.Table.FirstOrDefault(x => x.Id == robotsTxt.Id));
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Tests/Grand.Business.Cms.Tests/Startup/StartupApplicationTests.cs b/src/Tests/Grand.Business.Cms.Tests/Startup/StartupApplicationTests.cs
new file mode 100644
index 000000000..64b6e0d5c
--- /dev/null
+++ b/src/Tests/Grand.Business.Cms.Tests/Startup/StartupApplicationTests.cs
@@ -0,0 +1,31 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Grand.Business.Cms.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
diff --git a/src/Tests/Grand.Business.Common.Tests/Startup/StartupApplicationTests.cs b/src/Tests/Grand.Business.Common.Tests/Startup/StartupApplicationTests.cs
new file mode 100644
index 000000000..f07b68a46
--- /dev/null
+++ b/src/Tests/Grand.Business.Common.Tests/Startup/StartupApplicationTests.cs
@@ -0,0 +1,31 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Grand.Business.Common.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