Refactor message service and move tests to Application.Tests

Renamed IMessageService to IMessageCommandService and updated all usages accordingly. Moved and renamed test files from Govor.API.Tests to the new Govor.Application.Tests project, updating namespaces to match. Refactored message-related services and controllers to use the new naming and structure. Added Govor.Application.Tests project to the solution.

Govor.Application.Tests/Services/Friends/FriendRequestCommandServiceTests.cs

@@ -0,0 +1,285 @@
+using AutoFixture;
+using Govor.Application.Exceptions.FriendsService;
+using Govor.Application.Interfaces.Friends;
+using Govor.Application.Services.Friends;
+using Govor.Core.Models;
+using Govor.Core.Repositories.Friendships;
+using Govor.Core.Repositories.Users;
+using Govor.Data.Repositories.Exceptions;
+using Moq;
+
+namespace Govor.Application.Tests.Services.Friends;
+
+[TestFixture]
+public class FriendRequestCommandServiceTests
+{
+    private Fixture _fixture;
+    private Mock<IUsersRepository> _usersRepositoryMock;
+    private Mock<IFriendshipsRepository> _friendshipsRepositoryMock;
+    private IFriendRequestCommandService _service;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _fixture = new Fixture();
+        _fixture.Behaviors
+            .OfType<ThrowingRecursionBehavior>()
+            .ToList()
+            .ForEach(b => _fixture.Behaviors.Remove(b));
+        _fixture.Behaviors.Add(new OmitOnRecursionBehavior());
+
+        _usersRepositoryMock = new Mock<IUsersRepository>();
+        _friendshipsRepositoryMock = new Mock<IFriendshipsRepository>();
+
+        _service = new FriendRequestCommandService(_friendshipsRepositoryMock.Object);
+    }
+    
+    // SendFriendRequestAsync
+    [Test]
+    public void SendFriendRequestAsync_SendingToSelf_ThrowsInvalidOperationException()
+    {
+        // Arrange
+        var userId = Guid.NewGuid();
+
+        // Act & Assert
+        var ex = Assert.ThrowsAsync<InvalidOperationException>(() =>
+            _service.SendAsync(userId, userId));
+
+        Assert.That(ex.Message, Is.EqualTo("Cannot send a request to self user"));
+    }
+
+    [Test]
+    public void SendFriendRequestAsync_RequestAlreadyExists_ThrowsRequestAlreadySentException()
+    {
+        // Arrange
+        var fromUserId = Guid.NewGuid();
+        var toUserId = Guid.NewGuid();
+
+        _friendshipsRepositoryMock
+            .Setup(repo => repo.Exist(fromUserId, toUserId))
+            .Returns(true);
+
+        // Act & Assert
+        Assert.ThrowsAsync<RequestAlreadySentException>(() =>
+            _service.SendAsync(fromUserId, toUserId));
+    }
+
+    [Test]
+    public async Task SendFriendRequestAsync_ValidRequest_CallsAddAsync()
+    {
+        // Arrange
+        var fromUserId = Guid.NewGuid();
+        var toUserId = Guid.NewGuid();
+
+        _friendshipsRepositoryMock
+            .Setup(repo => repo.Exist(fromUserId, toUserId))
+            .Returns(false);
+
+        // Act
+        await _service.SendAsync(fromUserId, toUserId);
+
+        // Assert
+        _friendshipsRepositoryMock.Verify(repo =>
+                repo.AddAsync(It.Is<Friendship>(f =>
+                    f.RequesterId == fromUserId &&
+                    f.AddresseeId == toUserId &&
+                    f.Status == FriendshipStatus.Pending &&
+                    f.Id != Guid.Empty
+                )),
+            Times.Once);
+    }
+    
+    // AcceptFriendRequestAsync
+    [Test]
+    public async Task AcceptFriendRequestAsync_ValidRequest_CallsUpdateAsync()
+    {
+        var friendship = _fixture.Build<Friendship>()
+            .With(f => f.Status, FriendshipStatus.Pending)
+            .Create();
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.GetByIdAsync(friendship.Id))
+            .ReturnsAsync(friendship);
+
+        // Act: вызываем именно Accept, не Send
+        await _service.AcceptAsync(friendship.Id, friendship.AddresseeId);
+
+        // Assert
+        _friendshipsRepositoryMock.Verify(r => r.UpdateAsync(It.Is<Friendship>(f =>
+            f.Id == friendship.Id &&
+            f.RequesterId == friendship.RequesterId &&
+            f.AddresseeId == friendship.AddresseeId &&
+            f.Status == FriendshipStatus.Accepted
+        )), Times.Once);
+    }
+
+    [Test]
+    public void AcceptFriendRequestAsync_Throws_InvalidOperationException_IfStatusNotEqualPending()
+    {
+        var friendship = _fixture.Build<Friendship>()
+            .With(f => f.Status, FriendshipStatus.Accepted)
+            .Create();
+        
+        _friendshipsRepositoryMock
+            .Setup(r => r.GetByIdAsync(friendship.Id))
+            .ReturnsAsync(friendship);
+
+        // Act & Assert 
+        Assert.ThrowsAsync<InvalidOperationException>(async () => await _service.AcceptAsync(friendship.Id, friendship.AddresseeId));
+    }
+    [Test]
+    public void AcceptFriendRequestAsync_Throws_UnauthorizedAccessException_IfCurrentUserIdIsNotAddressee()
+    {
+        // Arrange
+        var friendship = _fixture.Build<Friendship>()
+            .With(f => f.Status, FriendshipStatus.Pending)
+            .Create();
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.GetByIdAsync(friendship.Id))
+            .ReturnsAsync(friendship);
+
+        var wrongUserId = Guid.NewGuid(); // не совпадает с AddresseeId
+
+        // Act & Assert
+        Assert.ThrowsAsync<UnauthorizedAccessException>(async () =>
+            await _service.AcceptAsync(friendship.Id, wrongUserId));
+    }
+    
+    [Test]
+    public void AcceptFriendRequestAsync_Throws_InvalidOperationException_IfFriendshipNotFound()
+    {
+        // Arrange
+        var requestId = Guid.NewGuid();
+        var userId = Guid.NewGuid();
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.GetByIdAsync(requestId))
+            .ThrowsAsync(new NotFoundByKeyException<Guid>(requestId));
+
+        // Act & Assert
+        Assert.ThrowsAsync<InvalidOperationException>(async () =>
+            await _service.AcceptAsync(requestId, userId));
+    }
+
+    [Test]
+    public async Task AcceptFriendRequestAsync_ChangesStatusToAccepted()
+    {
+        var friendship = _fixture.Build<Friendship>()
+            .With(f => f.Status, FriendshipStatus.Pending)
+            .Create();
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.GetByIdAsync(friendship.Id))
+            .ReturnsAsync(friendship);
+
+        Friendship updatedFriendship = null;
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.UpdateAsync(It.IsAny<Friendship>()))
+            .Callback<Friendship>(f => updatedFriendship = f)
+            .Returns(Task.CompletedTask);
+
+        await _service.AcceptAsync(friendship.Id, friendship.AddresseeId);
+
+        Assert.That(updatedFriendship.Status, Is.EqualTo(FriendshipStatus.Accepted));
+    }
+    
+    // RejectFriend
+    [Test]
+    public async Task RejectFriendRequestAsync_ValidRequest_CallsRemoveAsync()
+    {
+        var friendship = _fixture.Build<Friendship>()
+            .With(f => f.Status, FriendshipStatus.Pending)
+            .Create();
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.GetByIdAsync(friendship.Id))
+            .ReturnsAsync(friendship);
+        
+        await _service.RejectAsync(friendship.Id, friendship.AddresseeId);
+
+        // Assert
+        _friendshipsRepositoryMock.Verify(r => r.UpdateAsync(It.Is<Friendship>(f =>
+            f.Id == friendship.Id &&
+            f.RequesterId == friendship.RequesterId &&
+            f.AddresseeId == friendship.AddresseeId &&
+            f.Status == FriendshipStatus.Rejected
+        )), Times.Once);
+    }
+
+    [Test]
+    public void RejectFriendRequestAsync_Throws_InvalidOperationException_IfStatusNotEqualPendingOrReject()
+    {
+        var friendship = _fixture.Build<Friendship>()
+            .With(f => f.Status, FriendshipStatus.Accepted)
+            .Create();
+        
+        _friendshipsRepositoryMock
+            .Setup(r => r.GetByIdAsync(friendship.Id))
+            .ReturnsAsync(friendship);
+
+        // Act & Assert 
+        Assert.ThrowsAsync<InvalidOperationException>(async () => await _service.RejectAsync(friendship.Id, friendship.AddresseeId));
+    }
+    
+    [Test]
+    public void RejectFriendRequestAsync_Throws_UnauthorizedAccessException_IfCurrentUserIdIsNotAddressee()
+    {
+        // Arrange
+        var friendship = _fixture.Build<Friendship>()
+            .With(f => f.Status, FriendshipStatus.Pending)
+            .Create();
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.GetByIdAsync(friendship.Id))
+            .ReturnsAsync(friendship);
+
+        var wrongUserId = Guid.NewGuid(); // не совпадает с AddresseeId
+
+        // Act & Assert
+        Assert.ThrowsAsync<UnauthorizedAccessException>(async () =>
+            await _service.RejectAsync(friendship.Id, wrongUserId));
+    }
+    
+    [Test]
+    public void RejectFriendRequestAsync_Throws_InvalidOperationException_IfFriendshipNotFound()
+    {
+        // Arrange
+        var requestId = Guid.NewGuid();
+        var userId = Guid.NewGuid();
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.GetByIdAsync(requestId))
+            .ThrowsAsync(new NotFoundByKeyException<Guid>(requestId));
+
+        // Act & Assert
+        Assert.ThrowsAsync<InvalidOperationException>(async () =>
+            await _service.RejectAsync(requestId, userId));
+    }
+
+    [Test]
+    public async Task RejectFriendRequestAsync_ChangesStatusToAccepted()
+    {
+        var friendship = _fixture.Build<Friendship>()
+            .With(f => f.Status, FriendshipStatus.Pending)
+            .Create();
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.GetByIdAsync(friendship.Id))
+            .ReturnsAsync(friendship);
+
+        Friendship updatedFriendship = null;
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.UpdateAsync(It.IsAny<Friendship>()))
+            .Callback<Friendship>(f => updatedFriendship = f)
+            .Returns(Task.CompletedTask);
+
+        await _service.RejectAsync(friendship.Id, friendship.AddresseeId);
+
+        Assert.That(updatedFriendship.Status, Is.EqualTo(FriendshipStatus.Rejected));
+    }
+    
+   
+}

Govor.Application.Tests/Services/Friends/FriendRequestQueryServiceTests.cs

@@ -0,0 +1,130 @@
+using AutoFixture;
+using Govor.Application.Interfaces.Friends;
+using Govor.Application.Services.Friends;
+using Govor.Core.Models;
+using Govor.Core.Repositories.Friendships;
+using Govor.Core.Repositories.Users;
+using Govor.Data.Repositories.Exceptions;
+using Moq;
+
+namespace Govor.Application.Tests.Services.Friends;
+
+[TestFixture]
+public class FriendRequestQueryServiceTests
+{
+    private Fixture _fixture;
+    private Mock<IUsersRepository> _usersRepositoryMock;
+    private Mock<IFriendshipsRepository> _friendshipsRepositoryMock;
+    private IFriendRequestQueryService _service;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _fixture = new Fixture();
+        _fixture.Behaviors
+            .OfType<ThrowingRecursionBehavior>()
+            .ToList()
+            .ForEach(b => _fixture.Behaviors.Remove(b));
+        _fixture.Behaviors.Add(new OmitOnRecursionBehavior());
+
+        _usersRepositoryMock = new Mock<IUsersRepository>();
+        _friendshipsRepositoryMock = new Mock<IFriendshipsRepository>();
+
+        _service = new FriendRequestQueryService(_friendshipsRepositoryMock.Object);
+    }
+
+    // GetIncomingRequestsAsync
+    [Test]
+    public async Task GetIncomingRequestsAsync_ReturnsFriendships_IfFriendshipsExists()
+    {
+        // Arrange 
+        var userId = Guid.NewGuid();
+        
+        var friendships = _fixture.CreateMany<Friendship>().ToList();
+        
+        var user = _fixture.Build<User>()
+            .With(u => u.Id, userId)
+            .With(u => u.ReceivedFriendRequests, friendships)
+            .Create();
+        
+        friendships.ForEach(f =>
+        {
+            f.AddresseeId = userId;
+            f.Addressee = user;
+            f.Status = FriendshipStatus.Pending;
+        });
+        
+        _friendshipsRepositoryMock.Setup(f => f.FindByUserIdAsync(userId))
+            .ReturnsAsync(friendships);
+        
+        // Act 
+        var result = await _service.GetIncomingAsync(userId);
+        
+        // Assert 
+        Assert.That(result.Count, Is.EqualTo(friendships.Count));
+        Assert.That(result.Select(u => u.Id), Is.EquivalentTo(friendships.Select(f => f.Id)));
+    }
+    
+    [Test]
+    public void GetIncomingRequestsAsync_ThrowsInvalidOperationException_WhenUserNotFound()
+    {
+        // Arrange
+        var userId = Guid.NewGuid();
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.FindByUserIdAsync(userId))
+            .ThrowsAsync(new NotFoundByKeyException<Guid>(userId));
+
+        // Act & Assert
+        Assert.ThrowsAsync<InvalidOperationException>(async () =>
+            await _service.GetIncomingAsync(userId));
+    }
+    
+    // GetResponsesAsync
+    [Test]
+    public async Task GetResponsesAsync_ReturnsFriendships_IfFriendshipsExists()
+    {
+        // Arrange 
+        var userId = Guid.NewGuid();
+        
+        var friendships = _fixture.CreateMany<Friendship>().ToList();
+        
+        var user = _fixture.Build<User>()
+            .With(u => u.Id, userId)
+            .With(u => u.ReceivedFriendRequests, friendships)
+            .Create();
+        
+        friendships.ForEach(f =>
+        {
+            f.RequesterId = userId;
+            f.Requester = user;
+            f.Status = FriendshipStatus.Rejected;
+        });
+        
+        _friendshipsRepositoryMock.Setup(f => f.FindByUserIdAsync(userId))
+            .ReturnsAsync(friendships);
+        
+        // Act 
+        var result = await _service.GetResponsesAsync(userId);
+        
+        // Assert 
+        Assert.That(result.Count, Is.EqualTo(friendships.Count));
+        Assert.That(result.Select(u => u.Id), Is.EquivalentTo(friendships.Select(f => f.Id)));
+    }
+    
+    [Test]
+    public void GetResponsesAsync_ThrowsInvalidOperationException_WhenUserNotFound()
+    {
+        // Arrange
+        var userId = Guid.NewGuid();
+
+        _friendshipsRepositoryMock
+            .Setup(r => r.FindByUserIdAsync(userId))
+            .ThrowsAsync(new NotFoundByKeyException<Guid>(userId));
+
+        // Act & Assert
+        Assert.ThrowsAsync<InvalidOperationException>(async () =>
+            await _service.GetResponsesAsync(userId));
+    }
+
+}

Govor.Application.Tests/Services/Friends/FriendshipServiceTests.cs

@@ -0,0 +1,157 @@
+using AutoFixture;
+using Govor.Application.Exceptions.FriendsService;
+using Govor.Application.Interfaces.Friends;
+using Govor.Application.Services.Friends;
+using Govor.Core.Models;
+using Govor.Core.Repositories.Friendships;
+using Govor.Core.Repositories.Users;
+using Govor.Data.Repositories.Exceptions;
+using Moq;
+
+namespace Govor.Application.Tests.Services.Friends;
+
+[TestFixture]
+public class FriendshipServiceTests
+{
+    private Fixture _fixture;
+    private Mock<IUsersRepository> _usersRepositoryMock;
+    private Mock<IFriendshipsRepository> _friendshipsRepositoryMock;
+    IFriendshipService _service;
+    
+    [SetUp]
+    public void SetUp()
+    {
+        _fixture = new Fixture();
+        _fixture.Behaviors
+            .OfType<ThrowingRecursionBehavior>()
+            .ToList()
+            .ForEach(b => _fixture.Behaviors.Remove(b));
+        _fixture.Behaviors.Add(new OmitOnRecursionBehavior());
+
+        _usersRepositoryMock = new Mock<IUsersRepository>();
+        _friendshipsRepositoryMock = new Mock<IFriendshipsRepository>();
+
+        _service = new FriendshipService(_usersRepositoryMock.Object, _friendshipsRepositoryMock.Object);
+    }
+    
+    // SearchUsersAsync
+    [Test]
+    public async Task SearchUsersAsync_ReturnsUsers_IfNotAlreadyFriends()
+    {
+        // Arrange
+        var userId = _fixture.Create<Guid>();
+        var user = _fixture.Create<User>();
+        user.Id = Guid.NewGuid();
+
+        _usersRepositoryMock
+            .Setup(u => u.SearchPotentialFriendsAsync(userId, It.IsAny<string>()))
+            .ReturnsAsync(new List<User> { user });
+
+        _friendshipsRepositoryMock
+            .Setup(f => f.FindByUserIdAsync(userId))
+            .ReturnsAsync(new List<Friendship>()); // No friends
+
+        // Act
+        var result = await _service.SearchUsersAsync("test", userId);
+
+        // Assert
+        Assert.That(result, Has.Count.EqualTo(1));
+        Assert.That(result[0].Id, Is.EqualTo(user.Id));
+    }
+    
+    [Test]
+    public void SearchUsersAsync_Throws_SearchUsersException_IfThrowsNotFoundByKeyException_String_Guid()
+    {
+        // Arrange 
+        _usersRepositoryMock
+            .Setup(u => u.SearchPotentialFriendsAsync(It.IsAny<Guid>(), It.IsAny<string>()))
+            .ThrowsAsync(new NotFoundByKeyException<(string,Guid)>(("test",Guid.NewGuid()),"test"));
+        
+        // Axt & Assert 
+        Assert.ThrowsAsync<SearchUsersException>(async () => await _service.SearchUsersAsync("test", Guid.NewGuid()));
+    }
+    
+    [Test]
+    public async Task SearchUsersAsync_ReturnsUsersWithoutFriendships_IfThrowsNotFoundByKeyException_Guid()
+    {
+        // Arrange
+        var userId = _fixture.Create<Guid>();
+        var user = _fixture.Create<User>();
+        user.Id = Guid.NewGuid();
+
+        _usersRepositoryMock
+            .Setup(u => u.SearchPotentialFriendsAsync(userId, It.IsAny<string>()))
+            .ReturnsAsync(new List<User> { user });
+
+        _friendshipsRepositoryMock
+            .Setup(f => f.FindByUserIdAsync(userId))
+            .ThrowsAsync(new NotFoundByKeyException<Guid>(userId, "test"));
+        
+        // Act 
+        var result = await _service.SearchUsersAsync("test", userId);
+        
+        // Assert 
+        Assert.That(result, Has.Count.EqualTo(1));
+        Assert.That(result[0].Id, Is.EqualTo(user.Id));
+    }
+
+    [Test]
+    public void SearchUsersAsync_Throws_UnauthorizedAccessException_IfThrowsSomeExceptionInUsersRepository()
+    {
+        // Arrange 
+        _usersRepositoryMock
+            .Setup(u => u.SearchPotentialFriendsAsync(It.IsAny<Guid>(), It.IsAny<string>()))
+            .ThrowsAsync(new Exception("test"));
+        
+        // Act & Assert 
+        Assert.ThrowsAsync<UnauthorizedAccessException>(async () => await _service.SearchUsersAsync("test", Guid.NewGuid()));
+    }
+    
+    [Test]
+    public void SearchUsersAsync_Throws_UnauthorizedAccessException_IfThrowsSomeExceptionInFriendshipsRepository()
+    {
+        // Arrange 
+        _friendshipsRepositoryMock
+            .Setup(u => u.FindByUserIdAsync(It.IsAny<Guid>()))
+            .ThrowsAsync(new Exception("test"));
+        
+        // Act & Assert 
+        Assert.ThrowsAsync<UnauthorizedAccessException>(async () => await _service.SearchUsersAsync("test", Guid.NewGuid()));
+    }
+    
+    // GetFriendsAsync
+    [Test]
+    public async Task GetFriendsAsync_ReturnsUsers_IfUserExists()
+    {
+        // Arrange 
+        var userId = Guid.NewGuid();
+        var friendships = _fixture.CreateMany<Friendship>().ToList();
+        
+        friendships.ForEach(f =>
+        {
+            f.RequesterId = userId;
+            f.Status = FriendshipStatus.Accepted;
+        });
+        
+        _friendshipsRepositoryMock.Setup(f => f.FindByUserIdAsync(userId))
+            .ReturnsAsync(friendships);
+        
+        // Act 
+        var result = await _service.GetFriendsAsync(userId);
+        
+        // Assert 
+        Assert.That(result.Count, Is.EqualTo(friendships.Count));
+        Assert.That(result, Is.EquivalentTo(friendships.Select(f => f.Addressee)));
+    }
+    
+    [Test]
+    public void GetFriendsAsync_Throws_InvalidOperationException_IfUserNotExists()
+    {
+        // Arrange 
+        _friendshipsRepositoryMock.Setup(f => f.FindByUserIdAsync(It.IsAny<Guid>()))
+            .ThrowsAsync(new NotFoundByKeyException<Guid>(Guid.NewGuid()));
+        
+        // Act & Assert 
+        Assert.ThrowsAsync<InvalidOperationException>(async () => await _service.GetFriendsAsync(Guid.NewGuid()));
+    }
+}