Add more unit tests (#757)

* Reorganize tests into unit/integration pattern

* Make DbSets virtual so they can be overridden by tests

* Add MessageControllerTests

* Implement DigestMiddlewareTests

* Refactor SMTPHelper to follow DI pattern which allows for mocking in unit tests.

* Fix MailQueueService service registration and shutdown

* Implement tests for Status and StatisticsController and reorganize tests

* Start working on UserControllerTests

* Start refactoring tests to use In-Memory EF provider

* Refactor integration tests to reset the database every time
Change default unit testing database credentials

* Update credentials to use default root with different passwords

* Throw exception when integration db is not available instead of falling back to in-memory

* Evaluate DbConnected every time

* Remove default DbContext constructor

* Setup DbContexts with options builder

* Convert remaining Moq DbContexts to InMemory ones

* Add more tests and use Assert.IsType for testing status code

* Add collection attribute to LighthouseServerTest

* Remove unused directives and calculate digest in tests

* Fix digest calculation in tests

* Add test database call

* Clear rooms after each test

* Fix CommentControllerTests.cs

* Disable test parallelization for gameserver tests

* Fix failing tests

Fix SlotTests

Make CreateUser actually add user to database

Fix dbConnected Lazy and change expected status codes

Properly Remove fragment from url for digest calculation

Fix digest calculation for regular requests

[skip ci] Remove unused directive

Don't use Database CreateUser function

Get rid of userId argument for generating random user

Rewrite logic for generating random users

Fix integration tests

* Implement changes from self-code review

* Fix registration tests

* Replace MailQueueService usages with IMailService

ProjectLighthouse.Tests.GameApiTests/Unit/Controllers/CommentControllerTests.cs

@@ -0,0 +1,231 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using LBPUnion.ProjectLighthouse.Configuration;
+using LBPUnion.ProjectLighthouse.Database;
+using LBPUnion.ProjectLighthouse.Servers.GameServer.Controllers;
+using LBPUnion.ProjectLighthouse.Tests.Helpers;
+using LBPUnion.ProjectLighthouse.Types.Entities.Level;
+using LBPUnion.ProjectLighthouse.Types.Entities.Profile;
+using LBPUnion.ProjectLighthouse.Types.Levels;
+using Microsoft.AspNetCore.Mvc;
+using Xunit;
+
+namespace ProjectLighthouse.Tests.GameApiTests.Unit.Controllers;
+
+[Trait("Category", "Unit")]
+public class CommentControllerTests
+{
+    [Fact]
+    public async Task PostComment_ShouldPostProfileComment_WhenBodyIsValid()
+    {
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase();
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("<comment><message>test</message></comment>");
+
+        const string expectedCommentMessage = "test";
+
+        IActionResult result = await commentController.PostComment("unittest", null, 0);
+
+        Assert.IsType<OkResult>(result);
+        CommentEntity? comment = dbMock.Comments.FirstOrDefault();
+        Assert.NotNull(comment);
+        Assert.Equal(expectedCommentMessage, comment.Message);
+    }
+
+    [Fact]
+    public async Task PostComment_ShouldCensorComment_WhenFilterEnabled()
+    {
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase();
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("<comment><message>zamn</message></comment>");
+
+        CensorConfiguration.Instance.FilteredWordList = new List<string>
+        {
+            "zamn",
+        };
+        CensorConfiguration.Instance.UserInputFilterMode = FilterMode.Asterisks;
+        const string expectedCommentMessage = "****";
+
+        IActionResult result = await commentController.PostComment("unittest", null, 0);
+
+
+        Assert.IsType<OkResult>(result);
+        CommentEntity? comment = dbMock.Comments.FirstOrDefault();
+        Assert.NotNull(comment);
+        Assert.Equal(expectedCommentMessage, comment.Message);
+    }
+
+    [Fact]
+    public async Task PostComment_ShouldCensorComment_WhenFilterDisabled()
+    {
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase();
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("<comment><message>zamn</message></comment>");
+
+        CensorConfiguration.Instance.FilteredWordList = new List<string>
+        {
+            "zamn",
+        };
+        CensorConfiguration.Instance.UserInputFilterMode = FilterMode.None;
+
+        IActionResult result = await commentController.PostComment("unittest", null, 0);
+
+        const string expectedCommentMessage = "zamn";
+
+        Assert.IsType<OkResult>(result);
+        CommentEntity? comment = dbMock.Comments.FirstOrDefault();
+        Assert.NotNull(comment);
+        Assert.Equal(expectedCommentMessage, comment.Message);
+    }
+
+    [Fact]
+    public async Task PostComment_ShouldPostUserLevelComment_WhenBodyIsValid()
+    {
+        List<SlotEntity> slots = new()
+        {
+            new SlotEntity
+            {
+                SlotId = 1,
+                CreatorId = 1,
+                Type = SlotType.User,
+            },
+        };
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase(new[]{slots,});
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("<comment><message>test</message></comment>");
+
+        const string expectedCommentMessage = "test";
+
+        IActionResult result = await commentController.PostComment(null, "user", 1);
+
+        Assert.IsType<OkResult>(result);
+        CommentEntity? comment = dbMock.Comments.FirstOrDefault();
+        Assert.NotNull(comment);
+        Assert.Equal(expectedCommentMessage, comment.Message);
+    }
+
+    [Fact]
+    public async Task PostComment_ShouldPostDeveloperLevelComment_WhenBodyIsValid()
+    {
+        List<SlotEntity> slots = new()
+        {
+            new SlotEntity
+            {
+                SlotId = 1,
+                InternalSlotId = 12345,
+                CreatorId = 1,
+                Type = SlotType.Developer,
+            },
+        };
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase(new[] { slots, });
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("<comment><message>test</message></comment>");
+
+        const string expectedCommentMessage = "test";
+
+        IActionResult result = await commentController.PostComment(null, "developer", 12345);
+
+        Assert.IsType<OkResult>(result);
+        CommentEntity? comment = dbMock.Comments.FirstOrDefault();
+        Assert.NotNull(comment);
+        Assert.Equal(expectedCommentMessage, comment.Message);
+    }
+
+    [Fact]
+    public async Task PostComment_ShouldNotPostProfileComment_WhenTargetProfileInvalid()
+    {
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase();
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("<comment><message>test</message></comment>");
+
+        IActionResult result = await commentController.PostComment("unittest2", null, 0);
+
+        Assert.IsType<BadRequestResult>(result);
+    }
+
+    [Fact]
+    public async Task PostComment_ShouldNotPostUserLevelComment_WhenLevelInvalid()
+    {
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase();
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("<comment><message>test</message></comment>");
+
+        IActionResult result = await commentController.PostComment(null, "user", 1);
+
+        Assert.IsType<BadRequestResult>(result);
+    }
+
+    [Fact]
+    public async Task PostComment_ShouldNotPostComment_WhenBodyIsEmpty()
+    {
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase();
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("");
+
+        IActionResult result = await commentController.PostComment("unittest", null, 0);
+
+        Assert.IsType<BadRequestResult>(result);
+    }
+
+    [Fact]
+    public async Task PostComment_ShouldNotPostComment_WhenBodyIsInvalid()
+    {
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase();
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("<comment></comment>");
+
+        IActionResult result = await commentController.PostComment("unittest", null, 0);
+
+        Assert.IsType<BadRequestResult>(result);
+    }
+
+    [Fact]
+    public async Task PostComment_ShouldFail_WhenSlotTypeIsInvalid()
+    {
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase();
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("<comment><message>test</message></comment>");
+
+        IActionResult result = await commentController.PostComment(null, "banana", 0);
+
+        Assert.IsType<BadRequestResult>(result);
+    }
+
+    [Fact]
+    public async Task PostComment_ShouldFail_WhenAllArgumentsAreEmpty()
+    {
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase();
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("<comment><message>test</message></comment>");
+
+        IActionResult result = await commentController.PostComment(null, null, 0);
+
+        Assert.IsType<BadRequestResult>(result);
+    }
+
+    [Fact]
+    public async Task PostComment_ShouldFail_WhenSlotTypeAndUsernameAreProvided()
+    {
+        await using DatabaseContext dbMock = await MockHelper.GetTestDatabase();
+
+        CommentController commentController = new(dbMock);
+        commentController.SetupTestController("<comment><message>test</message></comment>");
+
+        IActionResult result = await commentController.PostComment("unittest", "user", 10);
+
+        Assert.IsType<BadRequestResult>(result);
+    }
+    
+}