Add unit tests and implement group repository interfaces

Introduces comprehensive unit tests for MessageService covering send, edit, and delete message scenarios. Adds and implements IGroupsRepository, IGroupsReader, and IGroupsWriter interfaces with method stubs in GroupRepository. Updates ChatGroup model with Description and ImageId fields, and registers GroupRepository in DI. Fixes parameter order in SendMessage record.

Govor.API.Tests/UnitTests/Services/MessageServiceTests.cs

@@ -0,0 +1,318 @@
+using Govor.Application.Exceptions.VerifyFriendship;
+using Govor.Application.Interfaces;
+using Govor.Application.Interfaces.Messages.Parameters;
+using Govor.Application.Services;
+using Govor.Core.Models;
+using Govor.Core.Repositories.Groups;
+using Govor.Core.Repositories.Messages;
+using Govor.Core.Repositories.Users;
+using Govor.Data.Repositories.Exceptions;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace Govor.API.Tests.UnitTests.Services;
+
+[TestFixture]
+public class MessageServiceTests
+{
+    private Mock<IMessagesRepository> _mockMessagesRepo;
+    private Mock<IUsersRepository> _mockUsersRepo;
+    private Mock<IGroupsRepository> _mockGroupsRepo;
+    private Mock<IVerifyFriendship> _mockVerifyFriendship;
+    private Mock<ILogger<MessageService>> _mockLogger;
+    private MessageService _messageService;
+    
+    [SetUp]
+    public void SetUp()
+    {
+        _mockMessagesRepo = new Mock<IMessagesRepository>();
+        _mockUsersRepo = new Mock<IUsersRepository>();
+        _mockGroupsRepo = new Mock<IGroupsRepository>();
+        _mockVerifyFriendship = new Mock<IVerifyFriendship>();
+        _mockLogger = new Mock<ILogger<MessageService>>();
+
+        _messageService = new MessageService(
+            _mockMessagesRepo.Object,
+            _mockUsersRepo.Object,
+            _mockGroupsRepo.Object,
+            _mockVerifyFriendship.Object,
+            _mockLogger.Object);
+    }
+
+    
+    // Test for SendMessageAsync action
+    [Test]
+    public async Task SendMessageAsync_ToUser_Success()
+    {
+        // Arrange
+        var senderId = Guid.NewGuid();
+        var recipientId = Guid.NewGuid();
+        
+        var sendMessageParams = new SendMessage("Hello", 
+            null,
+            recipientId,
+            RecipientType.User,
+            senderId,
+            DateTime.UtcNow,
+            new List<SendMedia>());
+
+        _mockUsersRepo.Setup(r => r.ExistsByIdAsync(recipientId)).ReturnsAsync(true);
+        _mockVerifyFriendship.Setup(v => v.VerifyAsync(senderId, recipientId)).Returns(Task.CompletedTask);
+        _mockMessagesRepo.Setup(r => r.AddAsync(It.IsAny<Message>())).Returns(Task.CompletedTask);
+
+        // Act
+        var result = await _messageService.SendMessageAsync(sendMessageParams);
+        // Assert 
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.IsSuccess, Is.EqualTo(true));
+        Assert.That(result.Exception, Is.Null);
+        
+        _mockMessagesRepo.Verify(r => r.AddAsync(It.Is<Message>(m => 
+            m.SenderId == senderId && 
+            m.RecipientId == recipientId && 
+            m.RecipientType == RecipientType.User &&
+            m.EncryptedContent == "Hello")), Times.Once);
+    }
+    
+    [Test]
+    public async Task SendMessageAsync_ToGroup_Success()
+    {
+        // Arrange
+        var senderId = Guid.NewGuid();
+        var groupId = Guid.NewGuid();
+        
+        var sendMessageParams = new SendMessage("Hello Group",
+            null,
+            groupId,
+            RecipientType.Group,
+            senderId,
+            DateTime.UtcNow,
+            new List<SendMedia>());
+
+        _mockGroupsRepo.Setup(r => r.Exists(groupId)).Returns(true);
+        _mockGroupsRepo.Setup(r => r.IsUserMemberOfGroupAsync(senderId, groupId)).Returns(true); 
+        _mockMessagesRepo.Setup(r => r.AddAsync(It.IsAny<Message>())).Returns(Task.CompletedTask);
+
+        // Act
+        var result = await _messageService.SendMessageAsync(sendMessageParams);
+        
+        // Assert 
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.IsSuccess, Is.EqualTo(true));
+        Assert.That(result.Exception, Is.Null);
+        _mockMessagesRepo.Verify(r => r.AddAsync(It.Is<Message>(m =>
+            m.RecipientId == groupId &&
+            m.RecipientType == RecipientType.Group)), Times.Once);
+    }
+    
+    [Test]
+    public async Task SendMessageAsync_ToUser_RecipientNotFound_ReturnsFailure()
+    {
+        // Arrange
+        var senderId = Guid.NewGuid();
+        var recipientId = Guid.NewGuid();
+        
+        var sendMessageParams = new SendMessage("Hello",
+            null,
+            recipientId,
+            RecipientType.User,
+            senderId,
+            DateTime.UtcNow,
+            new List<SendMedia>());
+
+        _mockUsersRepo.Setup(r => r.ExistsByIdAsync(recipientId)).ReturnsAsync(false);
+
+        // Act
+        var result = await _messageService.SendMessageAsync(sendMessageParams);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.IsSuccess, Is.EqualTo(false));
+        Assert.That(result.Exception, Is.Not.Null);
+        Assert.That(result.Exception,Is.TypeOf<KeyNotFoundException>());
+        Assert.That(result.MessageId, Is.EqualTo(Guid.Empty));
+    }
+
+    [Test]
+    public async Task SendMessageAsync_ToUser_FriendshipVerificationFails_ReturnsFailure()
+    {
+        // Arrange
+        var senderId = Guid.NewGuid();
+        var recipientId = Guid.NewGuid();
+        
+        var sendMessageParams = new SendMessage("Hello",
+            null,
+            recipientId,
+            RecipientType.User,
+            senderId,
+            DateTime.UtcNow,
+            new List<SendMedia>()
+            );
+
+        _mockUsersRepo.Setup(r => r.ExistsByIdAsync(recipientId)).ReturnsAsync(true);
+        _mockVerifyFriendship.Setup(v => v.VerifyAsync(senderId, recipientId)).ThrowsAsync(new FriendshipException("Not friends"));
+
+        // Act
+        var result = await _messageService.SendMessageAsync(sendMessageParams);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.IsSuccess, Is.EqualTo(false));
+        Assert.That(result.Exception, Is.Not.Null);
+        Assert.That(result.Exception,Is.TypeOf<FriendshipException>());
+        Assert.That(result.MessageId, Is.EqualTo(Guid.Empty));
+    }
+    
+    // Test for EditMessageAsync action 
+    [Test]
+    public async Task EditMessageAsync_Success()
+    {
+        // Arrange
+        var editorId = Guid.NewGuid();
+        var messageId = Guid.NewGuid();
+        
+        var originalMessage = new Message 
+        { 
+            Id = messageId, 
+            SenderId = editorId,
+            EncryptedContent = "Old",
+            RecipientId = Guid.NewGuid(),
+            RecipientType = RecipientType.User
+        };
+        
+        var editParams = new EditMessage(editorId, messageId, "New Content", DateTime.UtcNow);
+
+        _mockMessagesRepo.Setup(r => r.FindByIdAsync(messageId)).ReturnsAsync(originalMessage);
+        _mockMessagesRepo.Setup(r => r.UpdateAsync(It.IsAny<Message>())).Returns(Task.CompletedTask);
+
+        // Act
+        var result = await _messageService.EditMessageAsync(editParams);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.IsSuccess, Is.EqualTo(true));
+        Assert.That(result.OriginalMessage, Is.Not.Null);
+        
+        Assert.That(messageId, Is.EqualTo(result.OriginalMessage!.Id));
+        
+        _mockMessagesRepo.Verify(r => r.UpdateAsync(It.Is<Message>(m => 
+            m.Id == messageId && 
+            m.EncryptedContent == "New Content" && 
+            m.IsEdited == true && 
+            m.EditedAt == editParams.EditedAt)), Times.Once);
+    }
+    
+    [Test]
+    public async Task EditMessageAsync_MessageNotFound_ReturnsFailure()
+    {
+        // Arrange
+        var editorId = Guid.NewGuid();
+        var messageId = Guid.NewGuid();
+        var editParams = new EditMessage(editorId, messageId, "New Content", DateTime.UtcNow);
+
+        _mockMessagesRepo.Setup(r => r.FindByIdAsync(messageId)).
+            ThrowsAsync(new NotFoundByKeyException<Guid>(messageId));
+
+        // Act
+        var result = await _messageService.EditMessageAsync(editParams);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.IsSuccess, Is.EqualTo(false));
+        Assert.That(result.Exception, Is.Not.Null);
+        Assert.That(result.Exception,Is.TypeOf<NotFoundByKeyException<Guid>>());
+        Assert.That(result.OriginalMessage, Is.Null);
+    }
+
+    [Test]
+    public async Task EditMessageAsync_NotSender_ReturnsFailure()
+    {
+        // Arrange
+        var editorId = Guid.NewGuid();
+        var senderId = Guid.NewGuid(); // Different from editorId
+        var messageId = Guid.NewGuid();
+        var originalMessage = new Message { Id = messageId, SenderId = senderId, EncryptedContent = "Old" };
+        var editParams = new EditMessage(editorId, messageId, "New Content", DateTime.UtcNow);
+
+        _mockMessagesRepo.Setup(r => r.FindByIdAsync(messageId)).ReturnsAsync(originalMessage);
+
+        // Act
+        var result = await _messageService.EditMessageAsync(editParams);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.IsSuccess, Is.EqualTo(false));
+        Assert.That(result.Exception, Is.Not.Null);
+        Assert.That(result.Exception,Is.TypeOf<UnauthorizedAccessException>());
+        Assert.That(result.OriginalMessage, Is.Null);
+    }
+    
+    // Test for DeleteMessageAsync action
+    [Test]
+    public async Task DeleteMessageAsync_Success()
+    {
+        // Arrange
+        var deleterId = Guid.NewGuid();
+        var messageId = Guid.NewGuid();
+        var originalMessage = new Message { Id = messageId, SenderId = deleterId, RecipientId = Guid.NewGuid(), RecipientType = RecipientType.User };
+        var deleteParams = new DeleteMessage(deleterId, messageId);
+
+        _mockMessagesRepo.Setup(r => r.FindByIdAsync(messageId)).ReturnsAsync(originalMessage);
+        _mockMessagesRepo.Setup(r => r.RemoveAsync(messageId)).Returns(Task.CompletedTask);
+
+        // Act
+        var result = await _messageService.DeleteMessageAsync(deleteParams);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.IsSuccess, Is.EqualTo(true));
+        Assert.That(result.OriginalMessage, Is.Not.Null);
+        Assert.That(messageId, Is.EqualTo(result.OriginalMessage!.Id));
+        _mockMessagesRepo.Verify(r => r.RemoveAsync(messageId), Times.Once);
+    }
+    
+    [Test]
+    public async Task DeleteMessageAsync_MessageNotFound_ReturnsFailure()
+    {
+        // Arrange
+        var deleterId = Guid.NewGuid();
+        var messageId = Guid.NewGuid();
+        var deleteParams = new DeleteMessage(deleterId, messageId);
+
+        _mockMessagesRepo.Setup(r => r.FindByIdAsync(messageId)).
+            ThrowsAsync(new NotFoundByKeyException<Guid>(messageId));
+
+        // Act
+        var result = await _messageService.DeleteMessageAsync(deleteParams);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.IsSuccess, Is.EqualTo(false));
+        Assert.That(result.Exception, Is.Not.Null);
+        Assert.That(result.Exception,Is.TypeOf<NotFoundByKeyException<Guid>>());
+        Assert.That(result.OriginalMessage, Is.Null);
+    }
+
+    [Test]
+    public async Task DeleteMessageAsync_NotSender_ReturnsFailure()
+    {
+        // Arrange
+        var deleterId = Guid.NewGuid();
+        var senderId = Guid.NewGuid(); // Different
+        var messageId = Guid.NewGuid();
+        var originalMessage = new Message { Id = messageId, SenderId = senderId };
+        var deleteParams = new DeleteMessage(deleterId, messageId);
+        
+        _mockMessagesRepo.Setup(r => r.FindByIdAsync(messageId)).ReturnsAsync(originalMessage);
+
+        // Act
+        var result = await _messageService.DeleteMessageAsync(deleteParams);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.IsSuccess, Is.EqualTo(false));
+        Assert.That(result.Exception, Is.Not.Null);
+        Assert.That(result.Exception,Is.TypeOf<UnauthorizedAccessException>());
+        Assert.That(result.OriginalMessage, Is.Null);
+    }
+}

Govor.API/Extensions/ConfigurationProgramExtensions.cs

@@ -13,6 +13,7 @@ using Govor.Core.Infrastructure.Validators;
 using Govor.Core.Models;
 using Govor.Core.Repositories.Admins;
 using Govor.Core.Repositories.Friendships;
+using Govor.Core.Repositories.Groups;
 using Govor.Core.Repositories.Invaites;
 using Govor.Core.Repositories.MediasAttachments;
 using Govor.Core.Repositories.Messages;
@@ -60,6 +61,7 @@ public static class ConfigurationProgramExtensions
         services.AddScoped<IAdminsRepository, AdminsRepository>();
         services.AddScoped<IMediaAttachmentsRepository, MediaAttachmentsRepository>();
         services.AddScoped<IFriendshipsRepository, FriendshipsRepository>();
+        services.AddScoped<IGroupsRepository, GroupRepository>();
     }
 
     public static void AddValidators(this IServiceCollection services)

Govor.API/Hubs/ChatsHub.cs

@@ -9,7 +9,7 @@ using Microsoft.AspNetCore.SignalR;
 
 namespace Govor.API.Hubs;
 
-[Authorize]
+[Authorize] // api/chats
 public class ChatsHub : Hub
 {
     private readonly ILogger<ChatsHub> _logger;

Govor.Application/Interfaces/Messages/Parameters/SendMessage.cs

@@ -5,8 +5,8 @@ namespace Govor.Application.Interfaces.Messages.Parameters;
 public record SendMessage(
     string EncryptContent, 
     Guid? ReplyToMessageId,
-    RecipientType RecipientType,
     Guid RecipientId,
+    RecipientType RecipientType,
     Guid FromUserId,
     DateTime SendAt, 
     IEnumerable<SendMedia> Media);

Govor.Core/Models/ChatGroup.cs

@@ -4,6 +4,9 @@ public class ChatGroup
 {
     public Guid Id { get; set; }
     public string Name { get; set; }
+    public string Description { get; set; }
+    public Guid ImageId { get; set; }
+    
     public List<string> InviteCode { get; set; }
     public bool IsChannel { get; set; }
     public bool IsPrivate { get; set; }

Govor.Core/Repositories/Groups/IGroupsReader.cs

@@ -1,6 +1,13 @@
+using System.Text.RegularExpressions;
+
 namespace Govor.Core.Repositories.Groups;
 
 public interface IGroupsReader
 {
-    
+    public Task<List<Group>> GetAllAsync();
+    public Task<Group> GetByIdAsync(Guid id);
+    public Task<List<Group>> FindByNameAsync(string name);
+    public Task<List<Group>> GetByAdminIdAsync(Guid adminId);
+    public Task<List<Group>> GetByUserIdAsync(Guid adminId);
+    public bool IsUserMemberOfGroupAsync(Guid userId, Guid groupId);
 }

Govor.Core/Repositories/Groups/IGroupsRepository.cs

@@ -1,6 +1,6 @@
 namespace Govor.Core.Repositories.Groups;
 
-public interface IGroupsRepository : IGroupsReader, IGroupsExist, IGroupsWriter
+public interface IGroupsRepository : IGroupsReader, IGroupsWriter, IGroupsExist
 {
     
 }

Govor.Core/Repositories/Groups/IGroupsWriter.cs

@@ -1,6 +1,10 @@
+using System.Text.RegularExpressions;
+
 namespace Govor.Core.Repositories.Groups;
 
 public interface IGroupsWriter
 {
-    
+   Task Add(Group group);
+   Task Update(Group group);
+   Task Remove(Guid groupId);
 }

Govor.Data/Repositories/GroupRepository.cs

@@ -1,6 +1,62 @@
+using System.Text.RegularExpressions;
+using Govor.Core.Models;
+using Govor.Core.Repositories.Groups;
+
 namespace Govor.Data.Repositories;
 
-public class GroupRepository
+public class GroupRepository : IGroupsRepository
 {
-    
+    public Task<List<Group>> GetAllAsync()
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Group> GetByIdAsync(Guid id)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<List<Group>> FindByNameAsync(string name)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public Task<List<Group>> GetByAdminIdAsync(Guid adminId)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<List<Group>> GetByUserIdAsync(Guid adminId)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task Add(Group group)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task Update(Group group)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task Remove(Guid groupId)
+    {
+        throw new NotImplementedException();
+    }
+    public bool Exists(Guid groupId)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool Exists(ChatGroup chatGroup)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public bool IsUserMemberOfGroupAsync(Guid userId, Guid groupId)
+    {
+        throw new NotImplementedException();
+    }
 }