public async Task CreateAsync(CreateCategory command)
{
await _createValidator.ValidateCommandAsync(command);
var categoriesCount = await _dbContext.Categories
.Where(x => x.SiteId == command.SiteId && x.Status != StatusType.Deleted)
.CountAsync();
var sortOrder = categoriesCount + 1;
var category = new Category(command.Id,
command.SiteId,
command.Name,
sortOrder,
command.PermissionSetId);
_dbContext.Categories.Add(category);
_dbContext.Events.Add(new Event(command.SiteId,
command.UserId,
EventType.Created,
typeof(Category),
category.Id,
new
{
category.Name,
category.PermissionSetId,
category.SortOrder
}));
await _dbContext.SaveChangesAsync();
_cacheManager.Remove(CacheKeys.Categories(command.SiteId));
_cacheManager.Remove(CacheKeys.CurrentForums(command.SiteId));
}
public async Task <string> CreateAsync(CreateTopic command)
{
await _createValidator.ValidateCommandAsync(command);
var title = Regex.Replace(command.Title, @"\s+", " "); // Remove multiple spaces from title
var slug = string.IsNullOrWhiteSpace(command.Slug)
? await GenerateSlugAsync(command.ForumId, title)
: command.Slug;
var topic = Post.CreateTopic(command.Id,
command.ForumId,
command.UserId,
title,
slug,
command.Content,
command.Status);
_dbContext.Posts.Add(topic);
_dbContext.Events.Add(new Event(command.SiteId,
command.UserId,
EventType.Created,
typeof(Post),
command.Id,
new
{
command.ForumId,
title,
Slug = slug,
command.Content,
command.Status
}));
var forum = await _dbContext.Forums.Include(x => x.Category).FirstOrDefaultAsync(x => x.Id == topic.ForumId);
forum.UpdateLastPost(topic.Id);
forum.IncreaseTopicsCount();
forum.Category.IncreaseTopicsCount();
var user = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == topic.CreatedBy);
user.IncreaseTopicsCount();
await _dbContext.SaveChangesAsync();
_cacheManager.Remove(CacheKeys.Forum(forum.Id));
return(slug);
}
public async Task Should_return_false_when_name_is_not_unique_for_existing_permission_set()
{
var options = Shared.CreateContextOptions();
var siteId = Guid.NewGuid();
var permissionSetId = Guid.NewGuid();
using (var dbContext = new AtlasDbContext(options))
{
var site = new Site(siteId, "Name", "Title");
var permissionSet1 = new PermissionSet(siteId, "Permission Set 1", new List <PermissionCommand>());
var permissionSet2 = new PermissionSet(permissionSetId, siteId, "Permission Set 2", new List <PermissionCommand>());
dbContext.Sites.Add(site);
dbContext.PermissionSets.Add(permissionSet1);
dbContext.PermissionSets.Add(permissionSet2);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var sut = new PermissionSetRules(dbContext);
var actual = await sut.IsNameUniqueAsync(siteId, "Permission Set 1", permissionSetId);
Assert.IsFalse(actual);
}
}
public async Task Should_return_false_when_name_is_not_unique_for_existing_forum()
{
var options = Shared.CreateContextOptions();
var siteId = Guid.NewGuid();
var categoryId = Guid.NewGuid();
var forumId = Guid.NewGuid();
using (var dbContext = new AtlasDbContext(options))
{
var category = new Category(categoryId, siteId, "Category", 1, Guid.NewGuid());
var forum1 = new Forum(categoryId, "Forum 1", "My Forum", "my-forum", 1);
var forum2 = new Forum(forumId, categoryId, "Forum 2", "my-forum-2", "My Forum", 2);
dbContext.Categories.Add(category);
dbContext.Forums.Add(forum1);
dbContext.Forums.Add(forum2);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var sut = new ForumRules(dbContext);
var actual = await sut.IsNameUniqueAsync(siteId, categoryId, "Forum 1", forumId);
Assert.IsFalse(actual);
}
}
public async Task CreateAsync(CreateReply command)
{
await _createValidator.ValidateCommandAsync(command);
var reply = Post.CreateReply(command.Id,
command.TopicId,
command.ForumId,
command.UserId,
command.Content,
command.Status);
_dbContext.Posts.Add(reply);
_dbContext.Events.Add(new Event(command.SiteId,
command.UserId,
EventType.Created,
typeof(Post),
command.Id,
new
{
command.TopicId,
command.ForumId,
command.Content,
command.Status
}));
var topic = await _dbContext.Posts
.Include(x => x.Forum)
.ThenInclude(x => x.Category)
.FirstOrDefaultAsync(x => x.Id == reply.TopicId);
topic.UpdateLastReply(reply.Id);
topic.IncreaseRepliesCount();
topic.Forum.UpdateLastPost(reply.Id);
topic.Forum.IncreaseRepliesCount();
topic.Forum.Category.IncreaseRepliesCount();
var user = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == reply.CreatedBy);
user.IncreaseRepliesCount();
await _dbContext.SaveChangesAsync();
_cacheManager.Remove(CacheKeys.Forum(topic.ForumId));
}
public async Task Should_update_reply_and_add_event()
{
var options = Shared.CreateContextOptions();
var siteId = Guid.NewGuid();
var categoryId = Guid.NewGuid();
var forumId = Guid.NewGuid();
var topicId = Guid.NewGuid();
var category = new Category(categoryId, siteId, "Category", 1, Guid.NewGuid());
var forum = new Forum(forumId, categoryId, "Forum", "my-forum", "My Forum", 1);
var topic = Post.CreateTopic(topicId, forumId, Guid.NewGuid(), "Title", "slug", "Content", StatusType.Published);
var reply = Post.CreateReply(Guid.NewGuid(), topicId, forumId, Guid.NewGuid(), "Content", StatusType.Published);
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Categories.Add(category);
dbContext.Forums.Add(forum);
dbContext.Posts.Add(topic);
dbContext.Posts.Add(reply);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = Fixture.Build <UpdateReply>()
.With(x => x.Id, reply.Id)
.With(x => x.SiteId, siteId)
.With(x => x.ForumId, forumId)
.With(x => x.TopicId, topicId)
.Create();
var cacheManager = new Mock <ICacheManager>();
var createValidator = new Mock <IValidator <CreateReply> >();
var updateValidator = new Mock <IValidator <UpdateReply> >();
updateValidator
.Setup(x => x.ValidateAsync(command, new CancellationToken()))
.ReturnsAsync(new ValidationResult());
var sut = new ReplyService(dbContext,
cacheManager.Object,
createValidator.Object,
updateValidator.Object);
await sut.UpdateAsync(command);
var updatedReply = await dbContext.Posts.FirstOrDefaultAsync(x => x.Id == command.Id);
var @event = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == command.Id);
updateValidator.Verify(x => x.ValidateAsync(command, new CancellationToken()));
Assert.AreEqual(command.Content, updatedReply.Content);
Assert.NotNull(@event);
}
}
public async Task Should_move_forum_down_and_add_events()
{
var options = Shared.CreateContextOptions();
var categoryId = Guid.NewGuid();
var siteId = Guid.NewGuid();
var category = new Category(categoryId, siteId, "Category", 1, Guid.NewGuid());
var forum1 = new Forum(categoryId, "Forum 1", "my-forum-1", "Forum 1", 1);
var forum2 = new Forum(categoryId, "Forum 2", "my-forum-2", "Forum 2", 2);
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Categories.Add(category);
dbContext.Forums.Add(forum1);
dbContext.Forums.Add(forum2);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = new MoveForum
{
Id = forum1.Id,
Direction = Direction.Down,
SiteId = siteId
};
var cacheManager = new Mock <ICacheManager>();
var createValidator = new Mock <IValidator <CreateForum> >();
var updateValidator = new Mock <IValidator <UpdateForum> >();
var sut = new ForumService(dbContext,
cacheManager.Object,
createValidator.Object,
updateValidator.Object);
await sut.MoveAsync(command);
var updatedForum1 = await dbContext.Forums.FirstOrDefaultAsync(x => x.Id == forum1.Id);
var updatedForum2 = await dbContext.Forums.FirstOrDefaultAsync(x => x.Id == forum2.Id);
var event1 = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == forum1.Id);
var event2 = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == forum2.Id);
Assert.AreEqual(forum2.SortOrder, updatedForum1.SortOrder);
Assert.AreEqual(forum1.SortOrder, updatedForum2.SortOrder);
Assert.NotNull(event1);
Assert.NotNull(event2);
}
}
public async Task Should_update_permission_set_and_add_event()
{
var options = Shared.CreateContextOptions();
var permissionSet = new PermissionSet(Guid.NewGuid(), Guid.NewGuid(), "Default", new List <PermissionCommand>());
using (var dbContext = new AtlasDbContext(options))
{
dbContext.PermissionSets.Add(permissionSet);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = new UpdatePermissionSet
{
SiteId = permissionSet.SiteId,
Id = permissionSet.Id,
Name = "Permission Set",
Permissions = new List <PermissionCommand>
{
new PermissionCommand
{
Type = PermissionType.Start,
RoleId = Guid.NewGuid().ToString()
}
}
};
var cacheManager = new Mock <ICacheManager>();
var createValidator = new Mock <IValidator <CreatePermissionSet> >();
var updateValidator = new Mock <IValidator <UpdatePermissionSet> >();
updateValidator
.Setup(x => x.ValidateAsync(command, new CancellationToken()))
.ReturnsAsync(new ValidationResult());
var sut = new PermissionSetService(dbContext,
cacheManager.Object,
createValidator.Object,
updateValidator.Object);
await sut.UpdateAsync(command);
var updatedPermissionSet = await dbContext.PermissionSets.FirstOrDefaultAsync(x => x.Id == command.Id);
var @event = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == command.Id);
updateValidator.Verify(x => x.ValidateAsync(command, new CancellationToken()));
Assert.AreEqual(command.Name, updatedPermissionSet.Name);
Assert.NotNull(@event);
}
}
public async Task CreateAsync(CreateForum command)
{
await _createValidator.ValidateCommandAsync(command);
var forumsCount = await _dbContext.Forums
.Where(x => x.CategoryId == command.CategoryId && x.Status != StatusType.Deleted)
.CountAsync();
var sortOrder = forumsCount + 1;
var forum = new Forum(command.Id,
command.CategoryId,
command.Name,
command.Slug,
command.Description,
sortOrder,
command.PermissionSetId);
_dbContext.Forums.Add(forum);
_dbContext.Events.Add(new Event(command.SiteId,
command.UserId,
EventType.Created,
typeof(Forum),
forum.Id,
new
{
forum.Name,
forum.Slug,
forum.Description,
forum.CategoryId,
forum.PermissionSetId,
forum.SortOrder
}));
await _dbContext.SaveChangesAsync();
_cacheManager.Remove(CacheKeys.Categories(command.SiteId));
_cacheManager.Remove(CacheKeys.CurrentForums(command.SiteId));
}
public async Task Should_move_category_up_and_add_events()
{
var options = Shared.CreateContextOptions();
var siteId = Guid.NewGuid();
var category1 = new Category(siteId, "Category 1", 1, Guid.NewGuid());
var category2 = new Category(siteId, "Category 2", 2, Guid.NewGuid());
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Categories.Add(category1);
dbContext.Categories.Add(category2);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = new MoveCategory
{
Id = category2.Id,
Direction = Direction.Up,
SiteId = siteId
};
var cacheManager = new Mock <ICacheManager>();
var createValidator = new Mock <IValidator <CreateCategory> >();
var updateValidator = new Mock <IValidator <UpdateCategory> >();
var sut = new CategoryService(dbContext,
cacheManager.Object,
createValidator.Object,
updateValidator.Object);
await sut.MoveAsync(command);
var updatedCategory1 = await dbContext.Categories.FirstOrDefaultAsync(x => x.Id == category1.Id);
var updatedCategory2 = await dbContext.Categories.FirstOrDefaultAsync(x => x.Id == category2.Id);
var event1 = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == category1.Id);
var event2 = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == category2.Id);
Assert.AreEqual(category2.SortOrder, updatedCategory1.SortOrder);
Assert.AreEqual(category1.SortOrder, updatedCategory2.SortOrder);
Assert.NotNull(event1);
Assert.NotNull(event2);
}
}
public async Task Should_update_forum_and_add_event()
{
var options = Shared.CreateContextOptions();
var categoryId = Guid.NewGuid();
var siteId = Guid.NewGuid();
var category = new Category(categoryId, siteId, "Category", 1, Guid.NewGuid());
var forum = new Forum(categoryId, "Forum 1", "my-forum", "Forum 1", 1);
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Categories.Add(category);
dbContext.Forums.Add(forum);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = Fixture.Build <UpdateForum>()
.With(x => x.Id, forum.Id)
.With(x => x.CategoryId, forum.CategoryId)
.With(x => x.SiteId, siteId)
.Create();
var cacheManager = new Mock <ICacheManager>();
var createValidator = new Mock <IValidator <CreateForum> >();
var updateValidator = new Mock <IValidator <UpdateForum> >();
updateValidator
.Setup(x => x.ValidateAsync(command, new CancellationToken()))
.ReturnsAsync(new ValidationResult());
var sut = new ForumService(dbContext,
cacheManager.Object,
createValidator.Object,
updateValidator.Object);
await sut.UpdateAsync(command);
var updatedForum = await dbContext.Forums.FirstOrDefaultAsync(x => x.Id == command.Id);
var @event = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == command.Id);
updateValidator.Verify(x => x.ValidateAsync(command, new CancellationToken()));
Assert.AreEqual(command.Name, updatedForum.Name);
Assert.NotNull(@event);
}
}
public async Task Should_lock_topic_and_add_event()
{
var options = Shared.CreateContextOptions();
var siteId = Guid.NewGuid();
var categoryId = Guid.NewGuid();
var forumId = Guid.NewGuid();
var category = new Category(categoryId, siteId, "Category", 1, Guid.NewGuid());
var forum = new Forum(forumId, category.Id, "Forum", "my-forum", "My Forum", 1);
var topic = Post.CreateTopic(forumId, Guid.NewGuid(), "Title", "slug", "Content", StatusType.Published);
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Categories.Add(category);
dbContext.Forums.Add(forum);
dbContext.Posts.Add(topic);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = Fixture.Build <LockTopic>()
.With(x => x.Id, topic.Id)
.With(x => x.ForumId, forumId)
.With(x => x.SiteId, siteId)
.Create();
var cacheManager = new Mock <ICacheManager>();
var createValidator = new Mock <IValidator <CreateTopic> >();
var updateValidator = new Mock <IValidator <UpdateTopic> >();
var sut = new TopicService(dbContext,
cacheManager.Object,
createValidator.Object,
updateValidator.Object);
await sut.LockAsync(command);
var lockedTopic = await dbContext.Posts.FirstOrDefaultAsync(x => x.Id == command.Id);
var @event = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == command.Id);
Assert.AreEqual(command.Locked, lockedTopic.Locked);
Assert.NotNull(@event);
}
}
public async Task Should_update_category_and_add_event()
{
var options = Shared.CreateContextOptions();
var permissionSet = new PermissionSet(Guid.NewGuid(), Guid.NewGuid(), "Default", new List <PermissionCommand>());
var category = new Category(Guid.NewGuid(), permissionSet.SiteId, "Category", 1, permissionSet.Id);
using (var dbContext = new AtlasDbContext(options))
{
dbContext.PermissionSets.Add(permissionSet);
dbContext.Categories.Add(category);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = Fixture.Build <UpdateCategory>()
.With(x => x.Id, category.Id)
.With(x => x.SiteId, category.SiteId)
.Create();
var cacheManager = new Mock <ICacheManager>();
var createValidator = new Mock <IValidator <CreateCategory> >();
var updateValidator = new Mock <IValidator <UpdateCategory> >();
updateValidator
.Setup(x => x.ValidateAsync(command, new CancellationToken()))
.ReturnsAsync(new ValidationResult());
var sut = new CategoryService(dbContext,
cacheManager.Object,
createValidator.Object,
updateValidator.Object);
await sut.UpdateAsync(command);
var updatedCategory = await dbContext.Categories.FirstOrDefaultAsync(x => x.Id == command.Id);
var @event = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == command.Id);
updateValidator.Verify(x => x.ValidateAsync(command, new CancellationToken()));
Assert.AreEqual(command.Name, updatedCategory.Name);
Assert.NotNull(@event);
}
}
public async Task Should_return_false_when_display_name_is_not_unique()
{
var options = Shared.CreateContextOptions();
var displayName = "Display Name";
using (var dbContext = new AtlasDbContext(options))
{
var user = new User(Guid.NewGuid().ToString(), "*****@*****.**", displayName);
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var sut = new UserRules(dbContext);
var actual = await sut.IsDisplayNameUniqueAsync(displayName);
Assert.IsFalse(actual);
}
}
public async Task UpdateAsync(UpdateSite command)
{
await _updateValidator.ValidateCommandAsync(command);
var site = await _dbContext.Sites
.FirstOrDefaultAsync(x =>
x.Id == command.SiteId);
if (site == null)
{
throw new DataException($"Site with Id {command.SiteId} not found.");
}
site.UpdateDetails(command.Title,
command.Theme,
command.Css,
command.Language,
command.Privacy,
command.Terms,
command.HeadScript);
_dbContext.Events.Add(new Event(site.Id,
command.UserId,
EventType.Updated,
typeof(Site),
site.Id,
new
{
site.Title,
site.PublicTheme,
site.PublicCss,
site.Language,
site.Privacy,
site.Terms,
site.HeadScript
}));
await _dbContext.SaveChangesAsync();
_cacheManager.Remove(CacheKeys.CurrentSite(site.Name));
}
public async Task Should_return_false_when_name_is_not_unique()
{
var options = Shared.CreateContextOptions();
var siteId = Guid.NewGuid();
var categoryName = "My Category";
using (var dbContext = new AtlasDbContext(options))
{
var category = new Category(siteId, categoryName, 1, Guid.NewGuid());
dbContext.Categories.Add(category);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var sut = new CategoryRules(dbContext);
var actual = await sut.IsNameUniqueAsync(siteId, categoryName);
Assert.IsFalse(actual);
}
}
public async Task Should_return_true_when_permission_set_is_valid()
{
var options = Shared.CreateContextOptions();
var site = new Site(Guid.NewGuid(), "Name", "Title");
var permissionSet = new PermissionSet(Guid.NewGuid(), site.Id, "Permission Set", new List <PermissionCommand>());
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Sites.Add(site);
dbContext.PermissionSets.Add(permissionSet);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(Shared.CreateContextOptions()))
{
var sut = new PermissionSetRules(dbContext);
var actual = await sut.IsValidAsync(site.Id, permissionSet.Id);
Assert.IsTrue(actual);
}
}
public async Task Should_return_true_when_forum_is_valid()
{
var options = Shared.CreateContextOptions();
var category = new Category(Guid.NewGuid(), Guid.NewGuid(), "Category", 1, Guid.NewGuid());
var forum = new Forum(Guid.NewGuid(), category.Id, "Forum", "my-forum", "My Forum", 1);
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Categories.Add(category);
dbContext.Forums.Add(forum);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var sut = new ForumRules(dbContext);
var actual = await sut.IsValidAsync(forum.Category.SiteId, forum.Id);
Assert.IsTrue(actual);
}
}
public async Task Should_delete_permission_set_and_reorder_other_categories_and_add_event()
{
var options = Shared.CreateContextOptions();
var siteId = Guid.NewGuid();
var permissionSet = new PermissionSet(siteId, "Permission Set", new List <PermissionCommand>());
using (var dbContext = new AtlasDbContext(options))
{
dbContext.PermissionSets.Add(permissionSet);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = Fixture.Build <DeletePermissionSet>()
.With(x => x.Id, permissionSet.Id)
.With(x => x.SiteId, siteId)
.Create();
var cacheManager = new Mock <ICacheManager>();
var createValidator = new Mock <IValidator <CreatePermissionSet> >();
var updateValidator = new Mock <IValidator <UpdatePermissionSet> >();
var sut = new PermissionSetService(dbContext,
cacheManager.Object,
createValidator.Object,
updateValidator.Object);
await sut.DeleteAsync(command);
var permissionSetDeleted = await dbContext.PermissionSets.FirstOrDefaultAsync(x => x.Id == command.Id);
var permissionSetEvent = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == command.Id);
Assert.AreEqual(StatusType.Deleted, permissionSetDeleted.Status);
Assert.NotNull(permissionSetEvent);
}
}
public async Task Should_return_false_when_display_name_is_not_unique_for_existing_member()
{
var options = Shared.CreateContextOptions();
var userId = Guid.NewGuid();
using (var dbContext = new AtlasDbContext(options))
{
var user1 = new User(Guid.NewGuid().ToString(), "*****@*****.**", "User 1");
var user2 = new User(userId, Guid.NewGuid().ToString(), "*****@*****.**", "User 2");
dbContext.Users.Add(user1);
dbContext.Users.Add(user2);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var sut = new UserRules(dbContext);
var actual = await sut.IsDisplayNameUniqueAsync("User 1", userId);
Assert.IsFalse(actual);
}
}
public async Task Should_update_user_and_add_event()
{
var options = Shared.CreateContextOptions();
var user = new User(Guid.NewGuid(), Guid.NewGuid().ToString(), "*****@*****.**", "Display Name");
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = Fixture.Build <UpdateUser>()
.With(x => x.Id, user.Id)
.Create();
var createValidator = new Mock <IValidator <CreateUser> >();
var updateValidator = new Mock <IValidator <UpdateUser> >();
updateValidator
.Setup(x => x.ValidateAsync(command, new CancellationToken()))
.ReturnsAsync(new ValidationResult());
var sut = new UserService(dbContext,
createValidator.Object,
updateValidator.Object);
await sut.UpdateAsync(command);
var updatedUser = await dbContext.Users.FirstOrDefaultAsync(x => x.Id == command.Id);
var @event = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == command.Id);
updateValidator.Verify(x => x.ValidateAsync(command, new CancellationToken()));
Assert.AreEqual(command.DisplayName, updatedUser.DisplayName);
Assert.NotNull(@event);
}
}
public async Task Should_update_site_and_add_event()
{
var options = Shared.CreateContextOptions();
var site = new Site(Guid.NewGuid(), "Name", "Title");
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Sites.Add(site);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = Fixture.Build <UpdateSite>()
.With(x => x.SiteId, site.Id)
.Create();
var cacheManager = new Mock <ICacheManager>();
var updateValidator = new Mock <IValidator <UpdateSite> >();
updateValidator
.Setup(x => x.ValidateAsync(command, new CancellationToken()))
.ReturnsAsync(new ValidationResult());
var sut = new SiteService(dbContext,
cacheManager.Object,
updateValidator.Object);
await sut.UpdateAsync(command);
var updatedSite = await dbContext.Sites.FirstOrDefaultAsync(x => x.Id == command.SiteId);
var @event = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == command.SiteId);
updateValidator.Verify(x => x.ValidateAsync(command, new CancellationToken()));
Assert.AreEqual(command.Title, updatedSite.Title);
Assert.NotNull(@event);
}
}
public async Task Should_return_false_when_name_is_not_unique_for_existing_category()
{
var options = Shared.CreateContextOptions();
var siteId = Guid.NewGuid();
var categoryId = Guid.NewGuid();
using (var dbContext = new AtlasDbContext(options))
{
var category1 = new Category(siteId, "Category 1", 1, Guid.NewGuid());
var category2 = new Category(categoryId, siteId, "Category 2", 2, Guid.NewGuid());
dbContext.Categories.Add(category1);
dbContext.Categories.Add(category2);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var sut = new CategoryRules(dbContext);
var actual = await sut.IsNameUniqueAsync(siteId, "Category 1", categoryId);
Assert.IsFalse(actual);
}
}
public async Task Should_return_true_when_topic_is_valid()
{
var options = Shared.CreateContextOptions();
var category = new Category(Guid.NewGuid(), Guid.NewGuid(), "Category", 1, Guid.NewGuid());
var forum = new Forum(Guid.NewGuid(), category.Id, "Forum", "my-forum", "My Forum", 1, Guid.NewGuid());
var topic = Post.CreateTopic(Guid.NewGuid(), forum.Id, Guid.NewGuid(), "Title", "slug", "Content", StatusType.Published);
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Categories.Add(category);
dbContext.Forums.Add(forum);
dbContext.Posts.Add(topic);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var sut = new TopicRules(dbContext);
var actual = await sut.IsValidAsync(category.SiteId, forum.Id, topic.Id);
Assert.IsTrue(actual);
}
}
public async Task Should_suspend_user_and_add_event()
{
var options = Shared.CreateContextOptions();
var userId = Guid.NewGuid();
var user = new User(userId, Guid.NewGuid().ToString(), "*****@*****.**", "Display Name");
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = Fixture.Build <SuspendUser>()
.With(x => x.Id, user.Id)
.Create();
var createValidator = new Mock <IValidator <CreateUser> >();
var updateValidator = new Mock <IValidator <UpdateUser> >();
var sut = new UserService(dbContext,
createValidator.Object,
updateValidator.Object);
await sut.SuspendAsync(command);
var userSuspended = await dbContext.Users.FirstOrDefaultAsync(x => x.Id == user.Id);
var userEvent = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == user.Id);
Assert.AreEqual(StatusType.Suspended, userSuspended.Status);
Assert.NotNull(userEvent);
}
}
public async Task CreateAsync(CreateUser command)
{
await _createValidator.ValidateCommandAsync(command);
var displayName = await GenerateDisplayNameAsync();
var user = new User(command.Id,
command.IdentityUserId,
command.Email,
displayName);
if (command.Confirm)
{
user.Confirm();
}
_dbContext.Users.Add(user);
var userIdForEvent = command.UserId == Guid.Empty
? user.Id
: command.UserId;
_dbContext.Events.Add(new Event(command.SiteId,
userIdForEvent,
EventType.Created,
typeof(User),
command.Id,
new
{
UserId = command.IdentityUserId,
command.Email,
DisplayName = displayName,
user.Status
}));
await _dbContext.SaveChangesAsync();
}
public async Task Should_set_reply_as_answer_and_add_event()
{
var options = Shared.CreateContextOptions();
var siteId = Guid.NewGuid();
var categoryId = Guid.NewGuid();
var forumId = Guid.NewGuid();
var topicId = Guid.NewGuid();
var userId = Guid.NewGuid();
var category = new Category(categoryId, siteId, "Category", 1, Guid.NewGuid());
var forum = new Forum(forumId, categoryId, "Forum", "my-forum", "My Forum", 1);
var topic = Post.CreateTopic(topicId, forumId, Guid.NewGuid(), "Title", "slug", "Content", StatusType.Published);
var reply = Post.CreateReply(Guid.NewGuid(), topicId, forumId, userId, "Content", StatusType.Published);
var user = new User(userId, Guid.NewGuid().ToString(), "Email", "Display Name");
category.IncreaseRepliesCount();
forum.IncreaseRepliesCount();
topic.IncreaseRepliesCount();
user.IncreaseRepliesCount();
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Categories.Add(category);
dbContext.Forums.Add(forum);
dbContext.Posts.Add(topic);
dbContext.Posts.Add(reply);
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = new SetReplyAsAnswer
{
Id = reply.Id,
SiteId = siteId,
ForumId = forumId,
TopicId = topicId,
IsAnswer = true
};
var cacheManager = new Mock <ICacheManager>();
var createValidator = new Mock <IValidator <CreateReply> >();
var updateValidator = new Mock <IValidator <UpdateReply> >();
var sut = new ReplyService(dbContext,
cacheManager.Object,
createValidator.Object,
updateValidator.Object);
await sut.SetAsAnswerAsync(command);
var replyUpdated = await dbContext.Posts.Include(x => x.Topic).FirstOrDefaultAsync(x => x.Id == reply.Id);
var replyEvent = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == reply.Id);
Assert.AreEqual(true, replyUpdated.IsAnswer);
Assert.AreEqual(true, replyUpdated.Topic.HasAnswer);
Assert.NotNull(replyEvent);
}
}
public async Task EnsureDefaultSiteInitializedAsync()
{
if (await _dbContext.Sites.AnyAsync(x => x.Name == "Default"))
{
return;
}
var site = new Site("Default", "Atlas");
_dbContext.Sites.Add(site);
_dbContext.Events.Add(new Event(site.Id,
null,
EventType.Created,
typeof(Site),
site.Id,
new
{
site.Name,
site.Title,
site.PublicTheme,
site.PublicCss,
site.AdminTheme,
site.AdminCss
}));
var roleManager = _serviceProvider.GetRequiredService <RoleManager <IdentityRole> >();
var userManager = _serviceProvider.GetRequiredService <UserManager <IdentityUser> >();
// Roles
if (await roleManager.RoleExistsAsync(Consts.RoleNameAdmin) == false)
{
await roleManager.CreateAsync(new IdentityRole(Consts.RoleNameAdmin));
}
var roleAdmin = await roleManager.FindByNameAsync(Consts.RoleNameAdmin);
if (await roleManager.RoleExistsAsync(Consts.RoleNameModerator) == false)
{
await roleManager.CreateAsync(new IdentityRole(Consts.RoleNameModerator));
}
var roleModerator = await roleManager.FindByNameAsync(Consts.RoleNameModerator);
// Identity Users
var userAdmin = await userManager.FindByEmailAsync(_configuration["DefaultAdminUserEmail"]);
if (userAdmin == null)
{
userAdmin = new IdentityUser
{
Email = _configuration["DefaultAdminUserEmail"],
UserName = _configuration["DefaultAdminUserName"]
};
await userManager.CreateAsync(userAdmin, _configuration["DefaultAdminUserPassword"]);
var code = await userManager.GenerateEmailConfirmationTokenAsync(userAdmin);
await userManager.ConfirmEmailAsync(userAdmin, code);
}
await userManager.AddToRoleAsync(userAdmin, Consts.RoleNameAdmin);
var userNormalId = string.Empty;
if (_configuration["CreateDefaultNormalUser"] == "true")
{
var userNormal = await userManager.FindByEmailAsync(_configuration["DefaultNormalUserEmail"]);
if (userNormal == null)
{
userNormal = new IdentityUser
{
Email = _configuration["DefaultNormalUserEmail"],
UserName = _configuration["DefaultNormalUserName"]
};
await userManager.CreateAsync(userNormal, _configuration["DefaultNormalUserPassword"]);
var code = await userManager.GenerateEmailConfirmationTokenAsync(userNormal);
await userManager.ConfirmEmailAsync(userNormal, code);
userNormalId = userNormal.Id;
}
}
var userModeratorId = string.Empty;
if (_configuration["CreateDefaultModeratorUser"] == "true")
{
var userModerator = await userManager.FindByEmailAsync(_configuration["DefaultModeratorUserEmail"]);
if (userModerator == null)
{
userModerator = new IdentityUser
{
Email = _configuration["DefaultModeratorUserEmail"],
UserName = _configuration["DefaultModeratorUserName"]
};
await userManager.CreateAsync(userModerator, _configuration["DefaultModeratorUserPassword"]);
var code = await userManager.GenerateEmailConfirmationTokenAsync(userModerator);
await userManager.ConfirmEmailAsync(userModerator, code);
userModeratorId = userModerator.Id;
}
await userManager.AddToRoleAsync(userModerator, Consts.RoleNameModerator);
}
// Users
var memberAdmin = await _dbContext.Users.FirstOrDefaultAsync(x => x.IdentityUserId == userAdmin.Id);
if (memberAdmin == null)
{
memberAdmin = new User(userAdmin.Id, _configuration["DefaultAdminUserEmail"], _configuration["DefaultAdminUserDisplayName"]);
memberAdmin.Confirm();
_dbContext.Users.Add(memberAdmin);
_dbContext.Events.Add(new Event(site.Id,
null,
EventType.Created,
typeof(User),
memberAdmin.Id,
new
{
UserId = memberAdmin.IdentityUserId,
memberAdmin.Email,
memberAdmin.DisplayName
}));
}
if (_configuration["CreateDefaultNormalUser"] == "true")
{
var memberNormal = await _dbContext.Users.FirstOrDefaultAsync(x => x.IdentityUserId == userNormalId);
if (memberNormal == null)
{
memberNormal = new User(userNormalId, _configuration["DefaultNormalUserEmail"], _configuration["DefaultNormalUserDisplayName"]);
memberNormal.Confirm();
_dbContext.Users.Add(memberNormal);
_dbContext.Events.Add(new Event(site.Id,
null,
EventType.Created,
typeof(User),
memberNormal.Id,
new
{
UserId = memberNormal.IdentityUserId,
memberNormal.Email,
memberNormal.DisplayName
}));
}
}
if (_configuration["CreateDefaultModeratorUser"] == "true")
{
var memberModerator = await _dbContext.Users.FirstOrDefaultAsync(x => x.IdentityUserId == userModeratorId);
if (memberModerator == null)
{
memberModerator = new User(userModeratorId, _configuration["DefaultModeratorUserEmail"], _configuration["DefaultModeratorUserDisplayName"]);
memberModerator.Confirm();
_dbContext.Users.Add(memberModerator);
_dbContext.Events.Add(new Event(site.Id,
null,
EventType.Created,
typeof(User),
memberModerator.Id,
new
{
UserId = memberModerator.IdentityUserId,
memberModerator.Email,
memberModerator.DisplayName
}));
}
}
// Permission Sets
var permissionSetDefault = new PermissionSet(site.Id, "Default", new List <PermissionCommand>
{
new PermissionCommand {
Type = PermissionType.ViewForum, RoleId = Consts.RoleIdAll
},
new PermissionCommand {
Type = PermissionType.ViewTopics, RoleId = Consts.RoleIdAll
},
new PermissionCommand {
Type = PermissionType.Read, RoleId = Consts.RoleIdAll
},
new PermissionCommand {
Type = PermissionType.Start, RoleId = Consts.RoleIdRegistered
},
new PermissionCommand {
Type = PermissionType.Reply, RoleId = Consts.RoleIdRegistered
},
new PermissionCommand {
Type = PermissionType.Edit, RoleId = Consts.RoleIdRegistered
},
new PermissionCommand {
Type = PermissionType.Delete, RoleId = Consts.RoleIdRegistered
},
new PermissionCommand {
Type = PermissionType.Moderate, RoleId = roleModerator.Id
},
new PermissionCommand {
Type = PermissionType.ViewForum, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.ViewTopics, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Read, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Start, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Reply, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Edit, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Delete, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Moderate, RoleId = roleAdmin.Id
}
});
_dbContext.PermissionSets.Add(permissionSetDefault);
_dbContext.Events.Add(new Event(site.Id,
null,
EventType.Created,
typeof(PermissionSet),
permissionSetDefault.Id,
new
{
permissionSetDefault.Name
}));
var permissionSetMembersOnly = new PermissionSet(site.Id, "Members Only", new List <PermissionCommand>
{
new PermissionCommand {
Type = PermissionType.ViewForum, RoleId = Consts.RoleIdRegistered
},
new PermissionCommand {
Type = PermissionType.ViewTopics, RoleId = Consts.RoleIdRegistered
},
new PermissionCommand {
Type = PermissionType.Read, RoleId = Consts.RoleIdRegistered
},
new PermissionCommand {
Type = PermissionType.Start, RoleId = Consts.RoleIdRegistered
},
new PermissionCommand {
Type = PermissionType.Reply, RoleId = Consts.RoleIdRegistered
},
new PermissionCommand {
Type = PermissionType.Edit, RoleId = Consts.RoleIdRegistered
},
new PermissionCommand {
Type = PermissionType.Delete, RoleId = Consts.RoleIdRegistered
},
new PermissionCommand {
Type = PermissionType.Moderate, RoleId = roleModerator.Id
},
new PermissionCommand {
Type = PermissionType.ViewForum, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.ViewTopics, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Read, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Start, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Reply, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Edit, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Delete, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Moderate, RoleId = roleAdmin.Id
}
});
_dbContext.PermissionSets.Add(permissionSetMembersOnly);
_dbContext.Events.Add(new Event(site.Id,
null,
EventType.Created,
typeof(PermissionSet),
permissionSetMembersOnly.Id,
new
{
permissionSetMembersOnly.Name
}));
var permissionSetAdminOnly = new PermissionSet(site.Id, "Admin Only", new List <PermissionCommand>
{
new PermissionCommand {
Type = PermissionType.ViewForum, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.ViewTopics, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Read, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Start, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Reply, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Edit, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Delete, RoleId = roleAdmin.Id
},
new PermissionCommand {
Type = PermissionType.Moderate, RoleId = roleAdmin.Id
}
});
_dbContext.PermissionSets.Add(permissionSetAdminOnly);
_dbContext.Events.Add(new Event(site.Id,
null,
EventType.Created,
typeof(PermissionSet),
permissionSetAdminOnly.Id,
new
{
permissionSetAdminOnly.Name
}));
// Categories
var categoryGeneral = new Category(site.Id, "General", 1, permissionSetDefault.Id);
_dbContext.Categories.Add(categoryGeneral);
_dbContext.Events.Add(new Event(site.Id,
null,
EventType.Created,
typeof(Category),
categoryGeneral.Id,
new
{
categoryGeneral.Name,
categoryGeneral.PermissionSetId,
categoryGeneral.SortOrder
}));
// Forums
var forumWelcome = new Forum(categoryGeneral.Id, "Welcome", "welcome", "Welcome Forum", 1);
_dbContext.Forums.Add(forumWelcome);
_dbContext.Events.Add(new Event(site.Id,
null,
EventType.Created,
typeof(Forum),
forumWelcome.Id,
new
{
forumWelcome.Name,
forumWelcome.CategoryId,
forumWelcome.PermissionSetId,
forumWelcome.SortOrder
}));
var forumMembersOnly = new Forum(categoryGeneral.Id, "Members Only", "members-only", "Members Only Forum", 2, permissionSetMembersOnly.Id);
_dbContext.Forums.Add(forumMembersOnly);
_dbContext.Events.Add(new Event(site.Id,
null,
EventType.Created,
typeof(Forum),
forumMembersOnly.Id,
new
{
forumMembersOnly.Name,
forumMembersOnly.CategoryId,
forumMembersOnly.PermissionSetId,
forumMembersOnly.SortOrder
}));
var forumAdminOnly = new Forum(categoryGeneral.Id, "Admin Only", "admin-only", "Admin Only Forum", 3, permissionSetAdminOnly.Id);
_dbContext.Forums.Add(forumAdminOnly);
_dbContext.Events.Add(new Event(site.Id,
null,
EventType.Created,
typeof(Forum),
forumAdminOnly.Id,
new
{
forumAdminOnly.Name,
forumAdminOnly.CategoryId,
forumAdminOnly.PermissionSetId,
forumAdminOnly.SortOrder
}));
// Topics
var topicWelcomeTitle = "Welcome to Atlas!";
var topicWelcome = Post.CreateTopic(forumWelcome.Id, memberAdmin.Id, topicWelcomeTitle, topicWelcomeTitle.ToSlug(), "Welcome...", StatusType.Published);
_dbContext.Posts.Add(topicWelcome);
_dbContext.Events.Add(new Event(site.Id,
topicWelcome.CreatedBy,
EventType.Created,
typeof(Post),
topicWelcome.Id,
new
{
topicWelcome.ForumId,
topicWelcome.Title,
topicWelcome.Content,
topicWelcome.Status
}));
categoryGeneral.IncreaseTopicsCount();
forumWelcome.IncreaseTopicsCount();
memberAdmin.IncreaseTopicsCount();
// Save all changes
await _dbContext.SaveChangesAsync();
// Update last post
var forumWelcomeToUpdate = await _dbContext.Forums.FirstOrDefaultAsync(x => x.Id == forumWelcome.Id);
forumWelcomeToUpdate.UpdateLastPost(topicWelcome.Id);
await _dbContext.SaveChangesAsync();
}
public async Task Should_create_new_topic_and_add_event()
{
var options = Shared.CreateContextOptions();
var categoryId = Guid.NewGuid();
var forumId = Guid.NewGuid();
var userId = Guid.NewGuid();
var category = new Category(categoryId, Guid.NewGuid(), "Category", 1, Guid.NewGuid());
var forum = new Forum(forumId, category.Id, "Forum", "my-forum", "My Forum", 1);
var user = new User(userId, Guid.NewGuid().ToString(), "Email", "Display Name");
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Categories.Add(category);
dbContext.Forums.Add(forum);
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = Fixture.Build <CreateTopic>()
.With(x => x.ForumId, forum.Id)
.With(x => x.UserId, userId)
.Create();
var cacheManager = new Mock <ICacheManager>();
var createValidator = new Mock <IValidator <CreateTopic> >();
createValidator
.Setup(x => x.ValidateAsync(command, new CancellationToken()))
.ReturnsAsync(new ValidationResult());
var updateValidator = new Mock <IValidator <UpdateTopic> >();
var sut = new TopicService(dbContext,
cacheManager.Object,
createValidator.Object,
updateValidator.Object);
await sut.CreateAsync(command);
var topic = await dbContext.Posts.FirstOrDefaultAsync(x => x.Id == command.Id);
var @event = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == command.Id);
var updatedCategory = await dbContext.Categories.FirstOrDefaultAsync(x => x.Id == category.Id);
var updatedForum = await dbContext.Forums.FirstOrDefaultAsync(x => x.Id == forum.Id);
var updatedUser = await dbContext.Users.FirstOrDefaultAsync(x => x.Id == userId);
createValidator.Verify(x => x.ValidateAsync(command, new CancellationToken()));
Assert.NotNull(topic);
Assert.NotNull(@event);
Assert.AreEqual(category.TopicsCount + 1, updatedCategory.TopicsCount);
Assert.AreEqual(topic.Id, updatedForum.LastPostId);
Assert.AreEqual(forum.TopicsCount + 1, updatedForum.TopicsCount);
Assert.AreEqual(forum.TopicsCount + 1, updatedForum.TopicsCount);
Assert.AreEqual(user.TopicsCount + 1, updatedUser.TopicsCount);
}
}
public async Task Should_delete_topic_and_add_event()
{
var options = Shared.CreateContextOptions();
var siteId = Guid.NewGuid();
var categoryId = Guid.NewGuid();
var forumId = Guid.NewGuid();
var userId = Guid.NewGuid();
var category = new Category(categoryId, siteId, "Category", 1, Guid.NewGuid());
var forum = new Forum(forumId, category.Id, "Forum", "my-forum", "My Forum", 1);
var topic = Post.CreateTopic(forumId, userId, "Title", "slug", "Content", StatusType.Published);
var user = new User(userId, Guid.NewGuid().ToString(), "Email", "Display Name");
category.IncreaseTopicsCount();
forum.IncreaseTopicsCount();
user.IncreaseTopicsCount();
using (var dbContext = new AtlasDbContext(options))
{
dbContext.Categories.Add(category);
dbContext.Forums.Add(forum);
dbContext.Posts.Add(topic);
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
}
using (var dbContext = new AtlasDbContext(options))
{
var command = Fixture.Build <DeleteTopic>()
.With(x => x.Id, topic.Id)
.With(x => x.ForumId, forumId)
.With(x => x.SiteId, siteId)
.Create();
var cacheManager = new Mock <ICacheManager>();
var createValidator = new Mock <IValidator <CreateTopic> >();
var updateValidator = new Mock <IValidator <UpdateTopic> >();
var sut = new TopicService(dbContext,
cacheManager.Object,
createValidator.Object,
updateValidator.Object);
await sut.DeleteAsync(command);
var topicDeleted = await dbContext.Posts.FirstOrDefaultAsync(x => x.Id == topic.Id);
var topicEvent = await dbContext.Events.FirstOrDefaultAsync(x => x.TargetId == topic.Id);
var updatedCategory = await dbContext.Categories.FirstOrDefaultAsync(x => x.Id == category.Id);
var updatedForum = await dbContext.Forums.FirstOrDefaultAsync(x => x.Id == forum.Id);
var updatedUser = await dbContext.Users.FirstOrDefaultAsync(x => x.Id == user.Id);
Assert.AreEqual(StatusType.Deleted, topicDeleted.Status);
Assert.NotNull(topicEvent);
Assert.AreEqual(0, updatedCategory.TopicsCount);
Assert.AreEqual(0, updatedForum.TopicsCount);
Assert.AreEqual(0, updatedUser.TopicsCount);
}
}
