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.Cms.Services;
using Grand.Data;
using Grand.Domain.Blogs;
using Grand.Domain.Catalog;
using Grand.Infrastructure.Configuration;
using Grand.Infrastructure.Events;
using Grand.Mediator;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
namespace Grand.Business.Cms.Tests.Services;
[TestClass]
public class BlogServiceTests
{
private Mock<IRepository<BlogCategory>> _blogCategoryRepositoryMock;
private Mock<IRepository<BlogComment>> _blogCommentRepositoryMock;
private Mock<IRepository<BlogPost>> _blogPostRepositoryMock;
private Mock<IRepository<BlogProduct>> _blogProductRepositoryMock;
private BlogService _blogService;
private Mock<IMediator> _mediatorMock;
private CatalogSettings _settings;
[TestInitialize]
public void Init()
{
_blogPostRepositoryMock = new Mock<IRepository<BlogPost>>();
_blogCommentRepositoryMock = new Mock<IRepository<BlogComment>>();
_blogCategoryRepositoryMock = new Mock<IRepository<BlogCategory>>();
_blogProductRepositoryMock = new Mock<IRepository<BlogProduct>>();
_mediatorMock = new Mock<IMediator>();
_settings = new CatalogSettings();
_blogService = new BlogService(_blogPostRepositoryMock.Object, _blogCommentRepositoryMock.Object,
_blogCategoryRepositoryMock.Object, _blogProductRepositoryMock.Object, _mediatorMock.Object,
new AccessControlConfig());
}
[TestMethod]
public void DeleteBlogPost_NullArgument_ThrowException()
{
Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await _blogService.DeleteBlogPost(null),
"blogPost");
}
[TestMethod]
public async Task DeleteBlogPost_ValidArgument()
{
await _blogService.DeleteBlogPost(new BlogPost());
_blogPostRepositoryMock.Verify(c => c.DeleteAsync(It.IsAny<BlogPost>()), Times.Once);
_mediatorMock.Verify(c => c.Publish(It.IsAny<EntityDeleted<BlogPost>>(), default), Times.Once);
}
[TestMethod]
public async Task GetBlogPostById()
{
await _blogService.GetBlogPostById("id");
_blogPostRepositoryMock.Verify(c => c.GetByIdAsync(It.IsAny<string>()), Times.Once);
}
[TestMethod]
public void InsertBlogPost_NullArgument_ThrowException()
{
Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await _blogService.InsertBlogPost(null),
"blogPost");
}
[TestMethod]
public async Task InsertBlogPost_ValiArgument__InvokeRepository()
{
await _blogService.InsertBlogPost(new BlogPost());
_blogPostRepositoryMock.Verify(c => c.InsertAsync(It.IsAny<BlogPost>()), Times.Once);
_mediatorMock.Verify(c => c.Publish(It.IsAny<EntityInserted<BlogPost>>(), default), Times.Once);
}
[TestMethod]
public async Task UpdateBlogPost_ValiArgument_InvokeRepository()
{
await _blogService.UpdateBlogPost(new BlogPost());
_blogPostRepositoryMock.Verify(c => c.UpdateAsync(It.IsAny<BlogPost>()), Times.Once);
_mediatorMock.Verify(c => c.Publish(It.IsAny<EntityUpdated<BlogPost>>(), default), Times.Once);
}
[TestMethod]
public void UpdateBlogPost_NullArgument_ThrowException()
{
Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await _blogService.UpdateBlogPost(null),
"blogPost");
}
[TestMethod]
public async Task InsertBlogProduct_ValiArgument__InvokeRepository()
{
await _blogService.InsertBlogProduct(new BlogProduct());
_blogProductRepositoryMock.Verify(c => c.InsertAsync(It.IsAny<BlogProduct>()), Times.Once);
_mediatorMock.Verify(c => c.Publish(It.IsAny<EntityInserted<BlogProduct>>(), default), Times.Once);
}
[TestMethod]
public void InsertBlogProductInsertBlogProduct_NullArgument_ThrowException()
{
Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await _blogService.InsertBlogProduct(null),
"blogProduct");
}
[TestMethod]
public async Task UpdateBlogProduct_ValiArgument_InvokeRepository()
{
await _blogService.UpdateBlogProduct(new BlogProduct());
_blogProductRepositoryMock.Verify(c => c.UpdateAsync(It.IsAny<BlogProduct>()), Times.Once);
_mediatorMock.Verify(c => c.Publish(It.IsAny<EntityUpdated<BlogProduct>>(), default), Times.Once);
}
[TestMethod]
public void UpdateBlogProduct_NullArgument_ThrowException()
{
Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await _blogService.UpdateBlogProduct(null),
"blogProduct");
}
[TestMethod]
public async Task DeleteBlogProduct_ValidArgument_InvokeRepository()
{
await _blogService.DeleteBlogProduct(new BlogProduct());
_blogProductRepositoryMock.Verify(c => c.DeleteAsync(It.IsAny<BlogProduct>()), Times.Once);
_mediatorMock.Verify(c => c.Publish(It.IsAny<EntityDeleted<BlogProduct>>(), default), Times.Once);
}
[TestMethod]
public void DeleteBlogProduct_NullArgument_ThrowException()
{
Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await _blogService.DeleteBlogProduct(null),
"blogProduct");
}
[TestMethod]
public async Task InsertBlogCategory_ValiArgument__InvokeRepository()
{
await _blogService.InsertBlogCategory(new BlogCategory());
_blogCategoryRepositoryMock.Verify(c => c.InsertAsync(It.IsAny<BlogCategory>()), Times.Once);
_mediatorMock.Verify(c => c.Publish(It.IsAny<EntityInserted<BlogCategory>>(), default), Times.Once);
}
[TestMethod]
public void InsertBlogCategory_NullArgument_ThrowException()
{
Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await _blogService.InsertBlogCategory(null),
"blogCategory");
}
[TestMethod]
public async Task UpdateBlogCategory_ValiArgument_InvokeRepository()
{
await _blogService.UpdateBlogCategory(new BlogCategory());
_blogCategoryRepositoryMock.Verify(c => c.UpdateAsync(It.IsAny<BlogCategory>()), Times.Once);
_mediatorMock.Verify(c => c.Publish(It.IsAny<EntityUpdated<BlogCategory>>(), default), Times.Once);
}
[TestMethod]
public void UpdateBlogCategory_NullArgument_ThrowException()
{
Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await _blogService.UpdateBlogCategory(null),
"blogCategory");
}
[TestMethod]
public async Task DeleteBlogCategory_ValidArgument_InvokeRepository()
{
await _blogService.DeleteBlogCategory(new BlogCategory());
_blogCategoryRepositoryMock.Verify(c => c.DeleteAsync(It.IsAny<BlogCategory>()), Times.Once);
_mediatorMock.Verify(c => c.Publish(It.IsAny<EntityDeleted<BlogCategory>>(), default), Times.Once);
}
[TestMethod]
public void DeleteBlogCategory_NullArgument_ThrowException()
{
Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await _blogService.DeleteBlogCategory(null),
"blogCategory");
}
[TestMethod]
public async Task DeleteBlogComments_ValidArgument_InvokeRepository()
{
await _blogService.DeleteBlogComment(new BlogComment());
_blogCommentRepositoryMock.Verify(c => c.DeleteAsync(It.IsAny<BlogComment>()), Times.Once);
// _mediatorMock.Verify(c => c.Publish(It.IsAny<EntityDeleted<BlogComment>>(), default(CancellationToken)), Times.Once);
}
[TestMethod]
public async Task InsertBlogComment_ValiArgument__InvokeRepository()
{
await _blogService.InsertBlogComment(new BlogComment());
_blogCommentRepositoryMock.Verify(c => c.InsertAsync(It.IsAny<BlogComment>()), Times.Once);
_mediatorMock.Verify(c => c.Publish(It.IsAny<EntityInserted<BlogComment>>(), default), Times.Once);
}
}