Refactor group existence checks and add group repo tests

Renamed IGroupsExist and related methods from Exists to Exist for consistency. Added integration tests for GroupRepository. Introduced entity configurations for ChatGroup, GroupAdmins, GroupInvitation, and updated GroupMembership configuration. Updated usages and tests to match new method names and improved equality checks for ChatGroup.

Govor.API.Tests/IntegrationTests/EF/Repositories/GroupRepositoryTests.cs

@@ -0,0 +1,308 @@
+using AutoFixture;
+using Govor.Core.Infrastructure.Validators;
+using Govor.Core.Models;
+using Govor.Data;
+using Govor.Data.Repositories;
+using Govor.Data.Repositories.Exceptions;
+using Microsoft.EntityFrameworkCore;
+
+namespace Govor.API.Tests.IntegrationTests.EF.Repositories;
+
+[TestFixture]
+public class GroupRepositoryTests
+{
+    private Fixture _fixture;
+    private DbContextOptions<GovorDbContext> _options;
+    private IObjectValidator<ChatGroup> _validator = new ChatGroupValidator();
+    private int _testIteration = 0;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _testIteration += 1;
+
+        _fixture = new Fixture();
+
+        _fixture.Behaviors
+            .OfType<ThrowingRecursionBehavior>()
+            .ToList()
+            .ForEach(b => _fixture.Behaviors.Remove(b));
+
+        _fixture.Behaviors.Add(new OmitOnRecursionBehavior());
+
+        _options = new DbContextOptionsBuilder<GovorDbContext>()
+            .UseInMemoryDatabase(databaseName: $"DbGovor_{nameof(GroupRepositoryTests)}_{_testIteration}")
+            .Options;
+    }
+
+    [Test]
+    public async Task Given_NotEmptySetDb_When_GetAll_Then_ReturnAll()
+    {
+        // Arrange
+        var random = new Random();
+        var chats = _fixture.CreateMany<ChatGroup>(random.Next(2, 10)).ToList();
+
+        await using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+
+        context.ChatGroups.AddRange(chats);
+        await context.SaveChangesAsync();
+
+        // Act 
+
+        var result = await repository.GetAllAsync();
+
+        // Assert 
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Count, Is.EqualTo(chats.Count));
+        Assert.That(result, Is.EquivalentTo(chats));
+    }
+
+    [Test]
+    public void Given_EmptySetDb_When_GetAll_Should_Throw_NotFoundException()
+    {
+        // Arrange 
+        using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+
+        // Act & Assert 
+        Assert.ThrowsAsync<NotFoundException>(async () => await repository.GetAllAsync());
+    }
+
+    [Test]
+    public async Task Given_ValidChatId_When_GetById_Then_ReturnChat()
+    {
+        // Arrange 
+        var chats = _fixture.CreateMany<ChatGroup>(10);
+        var id = chats.First().Id;
+
+        await using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+
+        context.ChatGroups.AddRange(chats);
+        await context.SaveChangesAsync();
+
+        // Act
+        var result = await repository.GetByIdAsync(id);
+
+        // Assert 
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result, Is.EqualTo(chats.First()));
+    }
+
+    [Test]
+    public void Given_InvalidMessageId_When_FindById_Should_Throw_NotFoundByKeyException()
+    {
+        // Arrange 
+        using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+
+        // Act & Assert 
+        Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () =>
+            await repository.GetByIdAsync(_fixture.Create<Guid>()));
+    }
+
+    [Test]
+    public async Task Given_ValidQuery_When_SearchByNameAsync_Then_Returns_ChatGroups()
+    {
+        // Arrange
+        var random = new Random();
+        var chats = _fixture.CreateMany<ChatGroup>(random.Next(3, 10)).ToList();
+
+        using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+
+        context.ChatGroups.AddRange(chats);
+        await context.SaveChangesAsync();
+
+        // Act 
+        var result = await repository.SearchByNameAsync(chats[0].Name[..14]);
+
+        // Assert 
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Count, Is.EqualTo(1));
+        Assert.That(result.First(), Is.EqualTo(chats.First()));
+    }
+
+    [Test]
+    public void Given_InvalidQuery_When_SearchPotentialFriendsAsync_Should_Throw_NotFoundByKeyException()
+    {
+        // Arrange 
+        using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+
+        // Act & Assert 
+        Assert.ThrowsAsync<NotFoundByKeyException<string>>(async () => await
+            repository.SearchByNameAsync(_fixture.Create<string>()));
+    }
+
+    [Test]
+    public async Task Given_ValidAdminId_When_GetByAdminIdAsync_Returns_ChatGroups()
+    {
+        // Arrange 
+        var random = new Random();
+        var chats = _fixture.CreateMany<ChatGroup>(random.Next(3, 10)).ToList();
+        var adminId = chats.First().Admins.First().UserId;
+
+        using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+
+        context.ChatGroups.AddRange(chats);
+        await context.SaveChangesAsync();
+        // Act 
+        var result = await repository.GetByAdminIdAsync(adminId);
+        // Assert 
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Count, Is.EqualTo(1));
+        Assert.That(result.First(), Is.EqualTo(chats.First()));
+    }
+
+    [Test]
+    public void Given_ValidInvalidAdminId_When_GetByAdminIdAsync_Throws_NotFoundByKeyException()
+    {
+        // Arrange 
+        using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+
+        // Act & Assert 
+        Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await
+            repository.GetByAdminIdAsync(_fixture.Create<Guid>()));
+    }
+    [Test]
+    public async Task Given_ValidMemberId_When_GetByAdminIdAsync_Returns_ChatGroups()
+    {
+        // Arrange 
+        var random = new Random();
+        var chats = _fixture.CreateMany<ChatGroup>(random.Next(3, 10)).ToList();
+        var userId = chats.First().Members.First().UserId;
+
+        using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+
+        context.ChatGroups.AddRange(chats);
+        await context.SaveChangesAsync();
+        // Act 
+        var result = await repository.GetByUserIdAsync(userId);
+        // Assert 
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Count, Is.EqualTo(1));
+        Assert.That(result.First(), Is.EqualTo(chats.First()));
+    }
+
+    [Test]
+    public void Given_ValidInvalidMemberId_When_GetByAdminIdAsync_Throws_NotFoundByKeyException()
+    {
+        // Arrange 
+        using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+
+        // Act & Assert 
+        Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await
+            repository.GetByUserIdAsync(_fixture.Create<Guid>()));
+    }
+    
+    [Test]
+    public async Task Given_ValidChatGroup_When_AddAsync_Then_PrivateChatAdded()
+    {
+        // Arrange
+        var chat = _fixture.Create<ChatGroup>();
+        
+        await using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+    
+        // Act 
+        await repository.AddAsync(chat);
+        
+        // Assert 
+        Assert.That(context.ChatGroups.Count, Is.EqualTo(1));
+        Assert.That(context.ChatGroups.First(), Is.EqualTo(chat));
+    }
+    
+    [Test]
+    public void Given_InvalidChatGroup_When_AddAsync_Should_Throw_AdditionException()
+    {
+        // Arrange
+        using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+        
+        // Act & Assert 
+        Assert.ThrowsAsync<AdditionException>(async () => await repository.AddAsync(default));
+    }
+    
+    [Test]
+    public async Task Given_ExistChatGroup_When_Exist_Then_ReturnTrue()
+    {
+        // Arrange
+        var chat = _fixture.Create<ChatGroup>();
+        
+        await using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+        
+        context.ChatGroups.Add(chat);
+        await context.SaveChangesAsync();
+        
+        // Act 
+        var result1 = repository.Exist(chat.Id);
+        var result2 = repository.Exist(chat);
+        
+        
+        // Assert 
+        Assert.That(result1, Is.True);
+        Assert.That(result2, Is.True);
+    }
+
+    [Test]
+    public async Task Given_NotExistChatGroup_When_Exist_Then_ReturnFalse()
+    {
+        // Arrange
+        var chat = _fixture.Create<ChatGroup>();
+        
+        await using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+        
+        // Act 
+        var result1 = repository.Exist(chat.Id);
+        var result2 = repository.Exist(chat);
+        
+        // Assert 
+        Assert.That(result1, Is.False);
+        Assert.That(result2, Is.False);
+    }
+
+    [Test]
+    public async Task Given_ValidUserIdAndChatGroupId_When_IsUserMemberOfGroupAsync_Then_ReturnTrue()
+    {
+        // Arrange
+        var chat = _fixture.Create<ChatGroup>();
+        var userId = chat.Members.First().UserId;
+        
+        await using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+        
+        await context.ChatGroups.AddAsync(chat);
+        await context.SaveChangesAsync();
+        
+        // Act 
+        var result = await repository.IsUserMemberOfGroupAsync(userId, chat.Id);
+        
+        // Assert 
+        Assert.That(result, Is.True);
+    }
+    
+    [Test]
+    public async Task Given_InvalidValidUserIdAndChatGroupId_When_IsUserMemberOfGroupAsync_Then_ReturnFalse()
+    {
+        // Arrange
+        var chat = _fixture.Create<ChatGroup>();
+        var userId = chat.Members.First().UserId;
+        
+        await using var context = new GovorDbContext(_options);
+        var repository = new GroupRepository(context, _validator);
+        
+        // Act 
+        var result = await repository.IsUserMemberOfGroupAsync(userId, chat.Id);
+        
+        // Assert 
+        Assert.That(result, Is.False);
+    }
+}

Govor.API.Tests/IntegrationTests/EF/Repositories/PrivateChatsRepositoryTests.cs

@@ -43,14 +43,14 @@ public class PrivateChatsRepositoryTests
         var chats = _fixture.CreateMany<PrivateChat>(random.Next(2, 10)).ToList();
 
         await using var context = new GovorDbContext(_options);
-        var messagesRepository = new PrivateChatsRepository(context, _validator);
+        var repository = new PrivateChatsRepository(context, _validator);
 
         context.PrivateChats.AddRange(chats);
         await context.SaveChangesAsync();
 
         // Act 
 
-        var result = await messagesRepository.GetAllAsync();
+        var result = await repository.GetAllAsync();
 
         // Assert 
         Assert.That(result, Is.Not.Null);
@@ -134,7 +134,7 @@ public class PrivateChatsRepositoryTests
     }
     
     [Test]
-    public async Task Given_ValidMessage_When_AddAsync_Then_MessageAdded()
+    public async Task Given_ValidPrivateChat_When_AddAsync_Then_PrivateChatAdded()
     {
         // Arrange
         var chat = _fixture.Create<PrivateChat>();
@@ -151,7 +151,7 @@ public class PrivateChatsRepositoryTests
     }
     
     [Test]
-    public async Task Given_InvalidMessage_When_AddAsync_Should_Throw_AdditionException()
+    public async Task Given_InvalidPrivateChat_When_AddAsync_Should_Throw_AdditionException()
     {
         // Arrange
         await using var context = new GovorDbContext(_options);
@@ -162,7 +162,7 @@ public class PrivateChatsRepositoryTests
     }
     
     [Test]
-    public async Task Given_ExistMessage_When_Exist_Then_ReturnTrue()
+    public async Task Given_ExistPrivateChat_When_Exist_Then_ReturnTrue()
     {
         // Arrange
         var chat = _fixture.Create<PrivateChat>();
@@ -184,7 +184,7 @@ public class PrivateChatsRepositoryTests
     }
 
     [Test]
-    public async Task Given_NotExistMessage_When_Exist_Then_ReturnFalse()
+    public async Task Given_NotExistPrivateChat_When_Exist_Then_ReturnFalse()
     {
         // Arrange
         var chat = _fixture.Create<PrivateChat>();
@@ -200,4 +200,5 @@ public class PrivateChatsRepositoryTests
         Assert.That(result1, Is.False);
         Assert.That(result2, Is.False);
     }
+    
 }

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

@@ -94,7 +94,7 @@ public class MessageServiceTests
             DateTime.UtcNow,
             new List<SendMedia>());
 
-        _mockGroupsRepo.Setup(r => r.Exists(groupId)).Returns(true);
+        _mockGroupsRepo.Setup(r => r.Exist(groupId)).Returns(true);
         _mockGroupsRepo.Setup(r => r.IsUserMemberOfGroupAsync(senderId, groupId)).ReturnsAsync(true); 
         _mockMessagesRepo.Setup(r => r.AddAsync(It.IsAny<Message>())).Returns(Task.CompletedTask);
 

Govor.Application/Services/MessageService.cs

@@ -54,7 +54,7 @@ public class MessageService : IMessageService
             }
             else if (sendParams.RecipientType == RecipientType.Group)
             {
-                if (!_groupsRepository.Exists(sendParams.RecipientId))
+                if (!_groupsRepository.Exist(sendParams.RecipientId))
                 {
                     _logger.LogWarning("Attempt to send message to non-existent group {GroupId}", sendParams.RecipientId);
                     return new SendMessageResult(false, new KeyNotFoundException($"Recipient group {sendParams.RecipientId} not found."), default);

Govor.Core/Models/ChatGroup.cs

@@ -11,4 +11,16 @@ public class ChatGroup
     public List<GroupAdmins> Admins { get; set; } = new();
     public List<GroupMembership> Members { get; set; } = new();
     public List<GroupInvitation> InviteCodes { get; set; } = new();
+
+    public override bool Equals(object? obj)
+    {
+        ChatGroup chatGroup = obj as ChatGroup;
+        
+        return Id == chatGroup.Id &&
+               Name == chatGroup.Name &&
+               Description == chatGroup.Description &&
+               ImageId == chatGroup.ImageId &&
+               IsChannel == chatGroup.IsChannel &&
+               IsPrivate == chatGroup.IsPrivate;
+    }
 }

Govor.Core/Repositories/Groups/IGroupsExist.cs

@@ -4,6 +4,6 @@ namespace Govor.Core.Repositories.Groups;
 
 public interface IGroupsExist
 {
-    public bool Exists(Guid groupId);
-    public bool Exists(ChatGroup chatGroup);
+    public bool Exist(Guid groupId);
+    public bool Exist(ChatGroup chatGroup);
 }

Govor.Data/Configurations/ChatGroupConfigurator.cs

@@ -0,0 +1,31 @@
+using Govor.Core.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Govor.Data.Configurations;
+
+public class ChatGroupConfigurator : IEntityTypeConfiguration<ChatGroup>
+{
+    public void Configure(EntityTypeBuilder<ChatGroup> builder)
+    {
+        builder.HasKey(e => e.Id);
+
+        builder.Property(e => e.Name).IsRequired().HasMaxLength(100);
+        builder.Property(e => e.Description).HasMaxLength(500);
+
+        builder.HasMany(e => e.Members)
+            .WithOne()
+            .HasForeignKey(e => e.GroupId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasMany(e => e.Admins)
+            .WithOne()
+            .HasForeignKey(e => e.GroupId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasMany(e => e.InviteCodes)
+            .WithOne()
+            .HasForeignKey(e => e.GroupId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}

Govor.Data/Configurations/GroupAdminsConfiguration.cs

@@ -0,0 +1,16 @@
+using Govor.Core.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Govor.Data.Configurations;
+
+public class GroupAdminsConfiguration : IEntityTypeConfiguration<GroupAdmins>
+{
+    public void Configure(EntityTypeBuilder<GroupAdmins> builder)
+    {
+        builder.HasKey(e => e.Id);
+
+        builder.Property(e => e.UserId).IsRequired();
+        builder.Property(e => e.GroupId).IsRequired();
+    }
+}

Govor.Data/Configurations/GroupInvitationConfiguration.cs

@@ -0,0 +1,26 @@
+using Govor.Core.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Govor.Data.Configurations;
+
+public class GroupInvitationConfiguration : IEntityTypeConfiguration<GroupInvitation>
+{
+    public void Configure(EntityTypeBuilder<GroupInvitation> builder)
+    {
+        builder.HasKey(e => e.Id);
+
+        builder.Property(e => e.InvitationCode).IsRequired().HasMaxLength(200);
+        builder.Property(e => e.Description).HasMaxLength(500);
+        builder.Property(e => e.EndDate).IsRequired();
+        builder.Property(e => e.CreatedAt).IsRequired();
+        
+        builder.HasOne(e => e.UserMaker)
+            .WithMany() 
+            .HasForeignKey(e => e.UserMakerId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+
+        builder.Ignore(e => e.GroupMemberships);
+    }
+}

Govor.Data/Configurations/GroupMembershipConfiguration.cs

@@ -8,6 +8,16 @@ public class GroupMembershipConfiguration : IEntityTypeConfiguration<GroupMember
 {
     public void Configure(EntityTypeBuilder<GroupMembership> builder)
     {
-        builder.HasKey(m => new { m.GroupId, m.UserId });
+        builder.HasKey(e => e.Id);
+
+        builder.Property(e => e.UserId).IsRequired();
+        builder.Property(e => e.GroupId).IsRequired();
+        builder.Property(e => e.InvitationId).IsRequired();
+
+        // Optional: можно добавить навигацию к GroupInvitation
+        builder.HasOne<GroupInvitation>()
+            .WithMany()
+            .HasForeignKey(e => e.InvitationId)
+            .OnDelete(DeleteBehavior.SetNull);
     }
 }

Govor.Data/GovorDbContext.cs

@@ -36,6 +36,10 @@ public class GovorDbContext(DbContextOptions<GovorDbContext> options) : DbContex
         modelBuilder.ApplyConfiguration(new MediaAttachmentsConfiguration());
         modelBuilder.ApplyConfiguration(new MessageViewConfiguration());
         modelBuilder.ApplyConfiguration(new MediaFileConfiguration());
+        modelBuilder.ApplyConfiguration(new ChatGroupConfigurator());
+        modelBuilder.ApplyConfiguration(new GroupInvitationConfiguration());
+        modelBuilder.ApplyConfiguration(new GroupMembershipConfiguration());
+        modelBuilder.ApplyConfiguration(new GroupAdminsConfiguration());
         
         base.OnModelCreating(modelBuilder);
     }

Govor.Data/Repositories/GroupRepository.cs

@@ -139,12 +139,12 @@ public class GroupRepository : IGroupsRepository
         }
     }
     
-    public bool Exists(Guid groupId)
+    public bool Exist(Guid groupId)
     {
         return _context.ChatGroups.Any(g => g.Id == groupId);
     }
 
-    public bool Exists(ChatGroup chatGroup)
+    public bool Exist(ChatGroup chatGroup)
     {
         return _context.ChatGroups.Any(g => g.Id == chatGroup.Id &&
                                             g.IsChannel == chatGroup.IsChannel &&