Expand server tests and enforce coverage

Consolidate server tests under tests/, upgrade them to .NET 10, and add CI coverage thresholds and reports. Expand API and application boundary coverage while fixing related issues in media handling, friend blocking, session crypto, presence, username validation, and local storage.
This commit is contained in:
Artemy
2026-10-24 15:30:32 +07:00
parent 33550d4fc9
commit 2d99c57a3b
161 changed files with 5515 additions and 8419 deletions
+17 -1
View File
@@ -52,7 +52,23 @@ jobs:
run: dotnet build Govor.Server.slnx --no-restore --configuration Release run: dotnet build Govor.Server.slnx --no-restore --configuration Release
- name: Run tests - name: Run tests
run: dotnet test Govor.Server.Tests/Govor.Server.Tests.csproj --no-build --configuration Release run: dotnet test Govor.Server.slnx --no-build --no-restore --configuration Release --logger trx --results-directory artifacts/test-results --collect "XPlat Code Coverage;Format=json,cobertura"
- name: Check application coverage
shell: pwsh
run: ./tests/Measure-ApplicationCoverage.ps1 -ResultsDirectory artifacts/test-results
- name: Check API source coverage
shell: pwsh
run: ./tests/Measure-ApplicationCoverage.ps1 -ResultsDirectory artifacts/test-results -AssemblyName Govor.API -ExcludeGeneratedSources -MinimumLineCoverage 98 -MinimumBranchCoverage 92
- name: Upload test results
if: always()
uses: actions/upload-artifact@v4
with:
name: test-results-${{ matrix.database }}
path: artifacts/test-results
if-no-files-found: ignore
publish: publish:
needs: build-and-test needs: build-and-test
@@ -1,389 +0,0 @@
using AutoMapper;
using Govor.API.Controllers;
using Govor.Application.Interfaces.Infrastructure.Extensions;
using Govor.Application.Interfaces.UserSession;
using Govor.Contracts.DTOs;
using Govor.Domain.Models.Users;
using Govor.Data.Repositories.Exceptions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.API.Tests.Controllers;
[TestFixture]
[TestOf(typeof(SessionController))]
public class SessionControllerTests
{
private Mock<ILogger<SessionController>> _loggerMock;
private Mock<ICurrentUserService> _currentUserServiceMock;
private Mock<ICurrentUserSessionService> _currentUserSessionServiceMock;
private Mock<IUserSessionReader> _userSessionReaderMock;
private Mock<IUserSessionRevoker> _userSessionRevokerMock;
private Mock<IMapper> _mapperMock;
private SessionController _controller;
[SetUp]
public void SetUp()
{
_loggerMock = new Mock<ILogger<SessionController>>();
_currentUserServiceMock = new Mock<ICurrentUserService>();
_currentUserSessionServiceMock = new Mock<ICurrentUserSessionService>();
_userSessionReaderMock = new Mock<IUserSessionReader>();
_userSessionRevokerMock = new Mock<IUserSessionRevoker>();
_mapperMock = new Mock<IMapper>();
_controller = new SessionController(
_loggerMock.Object,
_currentUserServiceMock.Object,
_currentUserSessionServiceMock.Object,
_userSessionReaderMock.Object,
_userSessionRevokerMock.Object,
_mapperMock.Object);
}
#region GetAllSessions
[Test]
public async Task GetAllSessions_Successful_ReturnsOkWithMappedSessions()
{
// Arrange
var userId = Guid.NewGuid();
var sessions = new List<UserSession> { new UserSession { Id = Guid.NewGuid(), UserId = userId } };
var sessionDtos = new List<SessionDto> { new SessionDto { Id = sessions[0].Id } };
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_userSessionReaderMock.Setup(r => r.GetAllSessionsAsync(userId)).ReturnsAsync(sessions);
_mapperMock.Setup(m => m.Map<List<SessionDto>>(sessions)).Returns(sessionDtos);
// Act
var result = await _controller.GetAllSessions();
// Assert
Assert.That(result, Is.TypeOf<OkObjectResult>());
var okResult = result as OkObjectResult;
Assert.That(okResult.Value, Is.EqualTo(sessionDtos));
_loggerMock.VerifyNoOtherCalls();
}
[Test]
public async Task GetAllSessions_UnauthorizedAccess_ReturnsForbid()
{
// Arrange
var userId = Guid.NewGuid();
var exception = new UnauthorizedAccessException("Unauthorized");
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_userSessionReaderMock.Setup(r => r.GetAllSessionsAsync(userId)).ThrowsAsync(exception);
// Act
var result = await _controller.GetAllSessions();
// Assert
Assert.That(result, Is.TypeOf<ForbidResult>());
_loggerMock.Verify(l => l.Log(
LogLevel.Warning,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
exception,
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
}
[Test]
public async Task GetAllSessions_UnexpectedError_Returns500()
{
// Arrange
var userId = Guid.NewGuid();
var exception = new Exception("Unexpected error");
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_userSessionReaderMock.Setup(r => r.GetAllSessionsAsync(userId)).ThrowsAsync(exception);
// Act
var result = await _controller.GetAllSessions();
// Assert
Assert.That(result, Is.TypeOf<ObjectResult>());
var statusResult = result as ObjectResult;
Assert.That(statusResult.StatusCode, Is.EqualTo(500));
Assert.That(statusResult.Value, Is.EqualTo("Unexpected Error! Please try again later."));
_loggerMock.Verify(l => l.Log(
LogLevel.Error,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
exception,
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
}
#endregion
#region CloseSession
[Test]
public async Task CloseSession_ValidSessionId_ReturnsOk()
{
// Arrange
var userId = Guid.NewGuid();
var sessionId = Guid.NewGuid();
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
// Act
var result = await _controller.CloseSession(sessionId);
// Assert
Assert.That(result, Is.TypeOf<OkResult>());
_userSessionRevokerMock.Verify(r => r.CloseSessionByIdAsync(sessionId, userId), Times.Once());
_loggerMock.VerifyNoOtherCalls();
}
[Test]
public async Task CloseSession_EmptySessionId_ReturnsBadRequest()
{
// Arrange
var sessionId = Guid.Empty;
// Act
var result = await _controller.CloseSession(sessionId);
// Assert
Assert.That(result, Is.TypeOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
Assert.That(badRequestResult.Value, Is.EqualTo("Invalid sessionId."));
_userSessionRevokerMock.Verify(r => r.CloseSessionByIdAsync(It.IsAny<Guid>(), It.IsAny<Guid>()), Times.Never());
_loggerMock.VerifyNoOtherCalls();
}
[Test]
public async Task CloseSession_UnauthorizedAccess_ReturnsForbid()
{
// Arrange
var userId = Guid.NewGuid();
var sessionId = Guid.NewGuid();
var exception = new UnauthorizedAccessException("Unauthorized");
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_userSessionRevokerMock.Setup(r => r.CloseSessionByIdAsync(sessionId, userId)).ThrowsAsync(exception);
// Act
var result = await _controller.CloseSession(sessionId);
// Assert
Assert.That(result, Is.TypeOf<ForbidResult>());
_loggerMock.Verify(l => l.Log(
LogLevel.Warning,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
exception,
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
}
[Test]
public async Task CloseSession_NotFound_ReturnsNotFound()
{
// Arrange
var userId = Guid.NewGuid();
var sessionId = Guid.NewGuid();
var exception = new NotFoundException("Session not found");
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_userSessionRevokerMock.Setup(r => r.CloseSessionByIdAsync(sessionId, userId)).ThrowsAsync(exception);
// Act
var result = await _controller.CloseSession(sessionId);
// Assert
Assert.That(result, Is.TypeOf<NotFoundObjectResult>());
var notFoundResult = result as NotFoundObjectResult;
Assert.That(notFoundResult.Value, Is.EqualTo("Session not found"));
_loggerMock.Verify(l => l.Log(
LogLevel.Warning,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
exception,
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
}
[Test]
public async Task CloseSession_InvalidOperation_ReturnsBadRequest()
{
// Arrange
var userId = Guid.NewGuid();
var sessionId = Guid.NewGuid();
var exception = new InvalidOperationException("Invalid operation");
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_userSessionRevokerMock.Setup(r => r.CloseSessionByIdAsync(sessionId, userId)).ThrowsAsync(exception);
// Act
var result = await _controller.CloseSession(sessionId);
// Assert
Assert.That(result, Is.TypeOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
Assert.That(badRequestResult.Value, Is.EqualTo("Invalid operation"));
_loggerMock.Verify(l => l.Log(
LogLevel.Error,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
exception,
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
}
#endregion
#region CloseCurrentSession
[Test]
public async Task CloseCurrentSession_ValidSessionIdAndUserId_ReturnsOk()
{
// Arrange
var userId = Guid.NewGuid();
var sessionId = Guid.NewGuid();
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_currentUserSessionServiceMock.Setup(s => s.GetUserSessionId()).Returns(sessionId);
// Act
var result = await _controller.CloseCurrent();
// Assert
Assert.That(result, Is.TypeOf<OkResult>());
_userSessionRevokerMock.Verify(r => r.CloseSessionByIdAsync(sessionId, userId), Times.Once());
_loggerMock.VerifyNoOtherCalls();
}
[Test]
public async Task CloseCurrentSession_UnauthorizedAccess_ReturnsForbid()
{
// Arrange
var userId = Guid.NewGuid();
var sessionId = Guid.NewGuid();
var exception = new UnauthorizedAccessException("Unauthorized");
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_currentUserSessionServiceMock.Setup(s => s.GetUserSessionId()).Returns(sessionId);
_userSessionRevokerMock.Setup(r => r.CloseSessionByIdAsync(sessionId, userId)).ThrowsAsync(exception);
// Act
var result = await _controller.CloseCurrent();
// Assert
Assert.That(result, Is.TypeOf<ForbidResult>());
_loggerMock.Verify(l => l.Log(
LogLevel.Warning,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
exception,
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
}
[Test]
public async Task CloseCurrentSession_NotFound_ReturnsNotFound()
{
// Arrange
var userId = Guid.NewGuid();
var sessionId = Guid.NewGuid();
var exception = new NotFoundException("Session not found");
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_currentUserSessionServiceMock.Setup(s => s.GetUserSessionId()).Returns(sessionId);
_userSessionRevokerMock.Setup(r => r.CloseSessionByIdAsync(sessionId, userId)).ThrowsAsync(exception);
// Act
var result = await _controller.CloseCurrent();
// Assert
Assert.That(result, Is.TypeOf<NotFoundObjectResult>());
var notFoundResult = result as NotFoundObjectResult;
Assert.That(notFoundResult.Value, Is.EqualTo("Session not found"));
_loggerMock.Verify(l => l.Log(
LogLevel.Warning,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
exception,
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
}
[Test]
public async Task CloseCurrentSession_InvalidOperation_ReturnsBadRequest()
{
// Arrange
var userId = Guid.NewGuid();
var sessionId = Guid.NewGuid();
var exception = new InvalidOperationException("Invalid operation");
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_currentUserSessionServiceMock.Setup(s => s.GetUserSessionId()).Returns(sessionId);
_userSessionRevokerMock.Setup(r => r.CloseSessionByIdAsync(sessionId, userId)).ThrowsAsync(exception);
// Act
var result = await _controller.CloseCurrent();
// Assert
Assert.That(result, Is.TypeOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
Assert.That(badRequestResult.Value, Is.EqualTo("Invalid operation"));
_loggerMock.Verify(l => l.Log(
LogLevel.Error,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
exception,
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
}
#endregion
#region CloseAllSessions
[Test]
public async Task CloseAllSessions_Successful_ReturnsOk()
{
// Arrange
var userId = Guid.NewGuid();
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
// Act
var result = await _controller.CloseAllSessions();
// Assert
Assert.That(result, Is.TypeOf<OkResult>());
_userSessionRevokerMock.Verify(r => r.CloseAllSessionsAsync(userId), Times.Once());
_loggerMock.VerifyNoOtherCalls();
}
[Test]
public async Task CloseAllSessions_UnauthorizedAccess_ReturnsForbid()
{
// Arrange
var userId = Guid.NewGuid();
var exception = new UnauthorizedAccessException("Unauthorized");
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_userSessionRevokerMock.Setup(r => r.CloseAllSessionsAsync(userId)).ThrowsAsync(exception);
// Act
var result = await _controller.CloseAllSessions();
// Assert
Assert.That(result, Is.TypeOf<ForbidResult>());
_loggerMock.Verify(l => l.Log(
LogLevel.Warning,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
exception,
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
}
[Test]
public async Task CloseAllSessions_UnexpectedError_Returns500()
{
// Arrange
var userId = Guid.NewGuid();
var exception = new Exception("Unexpected error");
_currentUserServiceMock.Setup(s => s.GetCurrentUserId()).Returns(userId);
_userSessionRevokerMock.Setup(r => r.CloseAllSessionsAsync(userId)).ThrowsAsync(exception);
// Act
var result = await _controller.CloseAllSessions();
// Assert
Assert.That(result, Is.TypeOf<ObjectResult>());
var statusResult = result as ObjectResult;
Assert.That(statusResult.StatusCode, Is.EqualTo(500));
Assert.That(statusResult.Value, Is.EqualTo("Unexpected Error! Please try again later."));
_loggerMock.Verify(l => l.Log(
LogLevel.Error,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
exception,
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
}
#endregion
[TearDown]
public void TearDown()
{
_controller?.Dispose();
}
}
-31
View File
@@ -1,31 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<LangVersion>latest</LangVersion>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="AutoFixture" Version="5.0.0-preview0012" />
<PackageReference Include="coverlet.collector" Version="6.0.2" />
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.6" />
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.0.6" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
<PackageReference Include="Moq" Version="4.20.72" />
<PackageReference Include="NUnit" Version="4.4.0-beta.1" />
<PackageReference Include="NUnit.Analyzers" Version="4.4.0"/>
<PackageReference Include="NUnit3TestAdapter" Version="4.6.0"/>
</ItemGroup>
<ItemGroup>
<Using Include="NUnit.Framework" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Govor.API\Govor.API.csproj" />
</ItemGroup>
</Project>
-197
View File
@@ -1,197 +0,0 @@
using AutoFixture;
using Govor.API.Common.SignalR.Helpers;
using Govor.API.Hubs;
using Govor.Application.Interfaces.UserOnlineStatus;
using Govor.Domain.Models.Users;
using Govor.Domain.Repositories.Users;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.API.Tests.Hubs;
[TestFixture]
[TestOf(typeof(PresenceHub))]
public class PresenceHubTests
{
/*
private Mock<ILogger<PresenceHub>> _mockLogger;
private Mock<IUserNotificationScopeService> _mockUserNotification;
private Mock<IOnlineUserStore> _mockOnlineUserStore;
private Mock<IHubUserAccessor> _mockHubUserAccessor;
private Mock<IUsersRepository> _mockUserRepository;
private Mock<IHubCallerClients> _clientsMock = null!;
private Mock<IClientProxy> _clientProxyMock = null!;
private Mock<HubCallerContext> _mockContext = null!;
private Mock<IGroupManager> _groupManagerMock = null!;
private Fixture _fixture;
private PresenceHub _hub;
private Guid _userId;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors.OfType<ThrowingRecursionBehavior>().ToList().ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_mockLogger = new Mock<ILogger<PresenceHub>>();
_mockUserNotification = new Mock<IUserNotificationScopeService>();
_mockOnlineUserStore = new Mock<IOnlineUserStore>();
_mockHubUserAccessor = new Mock<IHubUserAccessor>();
_mockUserRepository = new Mock<IUsersRepository>();
_clientsMock = new Mock<IHubCallerClients>();
_clientProxyMock = new Mock<IClientProxy>();
_userId = Guid.NewGuid();
_mockHubUserAccessor.Setup(h => h.GetUserId(
It.IsAny<HubCallerContext>(),
It.IsAny<bool>()))
.Returns(_userId);
_clientsMock.Setup(c => c.Group(It.IsAny<string>())).Returns(_clientProxyMock.Object);
_mockContext = new Mock<HubCallerContext>();
_mockContext.Setup(c => c.ConnectionId).Returns("test-connection");
_groupManagerMock = new Mock<IGroupManager>();
_groupManagerMock.Setup(g => g.AddToGroupAsync(It.IsAny<string>(), It.IsAny<string>(), default))
.Returns(Task.CompletedTask);
_hub = new PresenceHub(
_mockLogger.Object,
_mockUserNotification.Object,
_mockOnlineUserStore.Object,
_mockHubUserAccessor.Object,
_mockUserRepository.Object)
{
Clients = _clientsMock.Object,
Context = _mockContext.Object,
Groups = _groupManagerMock.Object,
};
}
// Tests for OnConnectedAsync action
[Test]
public async Task OnConnectedAsync_SetsUserOnlineAndNotifiesFriends()
{
// Arrange
_mockUserRepository.Setup(f => f.ExistsByIdAsync(_userId))
.ReturnsAsync(true);
var friendsIds = _fixture.CreateMany<Guid>().ToList();
_mockUserNotification.Setup(n => n.GetNotifiedUsers(_userId))
.ReturnsAsync(friendsIds);
// Act
await _hub.OnConnectedAsync();
// Assert
_mockOnlineUserStore.Verify(store => store.SetOnlineUser(_userId), Times.Once);
_clientsMock.Verify(c => c.Group(It.IsAny<string>()), Times.Exactly(friendsIds.Count));
foreach (var friendId in friendsIds)
{
_clientProxyMock.Verify(proxy =>
proxy.SendCoreAsync("UserOnline",
It.Is<object[]>(args => args.Length == 1 && (Guid)args[0] == _userId),
It.IsAny<CancellationToken>()),
Times.Exactly(friendsIds.Count));
}
}
[Test]
public async Task OnConnectedAsync_UserIdInvalidOrNotExists_AbortsConnection()
{
// Arrange
_mockHubUserAccessor.Setup(h => h.GetUserId(It.IsAny<HubCallerContext>(), false))
.Returns(Guid.Empty);
// Act
await _hub.OnConnectedAsync();
// Assert
_mockOnlineUserStore.Verify(store => store.SetOnlineUser(It.IsAny<Guid>()), Times.Never);
_mockContext.Verify(c => c.Abort(), Times.Once);
}
[Test]
public async Task OnConnectedAsync_UserNotExists_AbortsConnection()
{
// Arrange
_mockUserRepository.Setup(f => f.ExistsByIdAsync(_userId))
.ReturnsAsync(false);
// Act
await _hub.OnConnectedAsync();
// Assert
_mockOnlineUserStore.Verify(store => store.SetOnlineUser(It.IsAny<Guid>()), Times.Never);
_mockContext.Verify(c => c.Abort(), Times.Once);
}
// Tests for OnDisconnectedAsync action
[Test]
public async Task OnDisconnectedAsync_SetsUserOffline_UpdatesWasOnline_NotifiesFriends()
{
// Arrange
var user = new User { Id = _userId, WasOnline = DateTime.MinValue };
var friendsIds = _fixture.CreateMany<Guid>().ToList();
_mockUserRepository.Setup(r => r.FindByIdAsync(_userId))
.ReturnsAsync(user);
_mockUserNotification.Setup(n => n.GetNotifiedUsers(_userId))
.ReturnsAsync(friendsIds);
// Act
await _hub.OnDisconnectedAsync(null!);
// Assert
_mockOnlineUserStore.Verify(store => store.SetOfflineUser(_userId), Times.Once);
_mockUserRepository.Verify(r => r.UpdateAsync(It.Is<User>(u => u.Id == _userId && u.WasOnline > DateTime.MinValue)), Times.Once);
_clientsMock.Verify(c => c.Group(It.IsAny<string>()), Times.AtLeastOnce);
foreach (var friendId in friendsIds)
{
_clientProxyMock.Verify(proxy =>
proxy.SendCoreAsync("UserOffline",
It.Is<object[]>(args => args.Length == 1 && (Guid)args[0] == _userId),
It.IsAny<CancellationToken>()),
Times.Exactly(friendsIds.Count));
}
}
[Test]
public async Task OnDisconnectedAsync_UserIdEmpty_LogsAndSkips()
{
// Arrange
_mockHubUserAccessor.Setup(h => h.GetUserId(It.IsAny<HubCallerContext>(), true))
.Returns(Guid.Empty);
// Act
await _hub.OnDisconnectedAsync(null!);
// Assert
_mockOnlineUserStore.Verify(s => s.SetOfflineUser(It.IsAny<Guid>()), Times.Never);
_mockUserRepository.Verify(r => r.UpdateAsync(It.IsAny<User>()), Times.Never);
_clientProxyMock.Verify(proxy =>
proxy.SendCoreAsync("UserOffline",
It.Is<object[]>(args => args.Length == 1 && (Guid)args[0] == _userId),
It.IsAny<CancellationToken>()),
Times.Never);
}
[TearDown]
public void TearDown()
{
_hub?.Dispose();
}
*/
}
@@ -1,246 +0,0 @@
using AutoFixture;
using Govor.API.Controllers.Authentication;
using Govor.Application.Authentication.Exceptions;
using Govor.Application.Exceptions.InvitesService;
using Govor.Application.Interfaces.Authentication;
using Govor.Application.Interfaces.UserSession;
using Govor.Contracts.Requests;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.API.Tests.IntegrationTests.Controllers;
[TestFixture]
public class AuthControllerTests
{
private Fixture _fixture;
private Mock<IAccountService> _accountServiceMock;
private Mock<IInvitesService> _invitesServiceMock;
private Mock<ILogger<AuthController>> _loggerMock;
private Mock<IUserSessionOpener> _userSessionOpenerMock;
private AuthController _controller;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors.OfType<ThrowingRecursionBehavior>().ToList().ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_accountServiceMock = new Mock<IAccountService>();
_invitesServiceMock = new Mock<IInvitesService>();
_loggerMock = new Mock<ILogger<AuthController>>();
_userSessionOpenerMock = new Mock<IUserSessionOpener>();
_controller = new AuthController(
_accountServiceMock.Object,
_invitesServiceMock.Object,
_userSessionOpenerMock.Object,
_loggerMock.Object
);
}
// Tests for Register action
[Test]
public async Task Register_ValidRequest_ReturnsOkWithToken()
{
// Arrange
var request = _fixture.Create<RegistrationRequest>();
var invitation = _fixture.Create<Invitation>();
var token = _fixture.Create<RefreshResult>();
var user = _fixture.Build<User>()
.With(x => x.Username).Create();
_invitesServiceMock.Setup(s => s.ValidateAsync(request.InviteLink)).ReturnsAsync(invitation);
_accountServiceMock.Setup(l => l.RegistrationAsync(request.Name, request.Password, invitation))
.ReturnsAsync(user);
_userSessionOpenerMock.Setup(f => f.OpenSessionAsync(user, request.DeviceInfo))
.ReturnsAsync(token);
// Act
var result = await _controller.Register(request);
// Assert
Assert.That(result, Is.InstanceOf<OkObjectResult>());
var okResult = result as OkObjectResult;
var response = okResult?.Value as RefreshResult;
Assert.That(response, Is.Not.Null);
Assert.That(response.accessToken, Is.EqualTo(token.accessToken));
Assert.That(response.refreshToken, Is.EqualTo(token.refreshToken));
}
[Test]
public async Task Register_InvalidModelState_ReturnsBadRequest()
{
// Arrange
var request = _fixture.Create<RegistrationRequest>();
_controller.ModelState.AddModelError("Error", "Sample error");
// Act
var result = await _controller.Register(request);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
[Test]
public async Task Register_InviteLinkInvalid_ReturnsBadRequest()
{
// Arrange
var request = _fixture.Create<RegistrationRequest>();
_invitesServiceMock.Setup(s => s.ValidateAsync(request.InviteLink)).ThrowsAsync(new InviteLinkInvalidException(request.InviteLink));
// Act
var result = await _controller.Register(request);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
var notFoundObjectResult = result as BadRequestObjectResult;
Assert.That(notFoundObjectResult.Value, Is.EqualTo("Invite link invalid."));
}
[Test]
public async Task Register_UserAlreadyExists_ReturnsBadRequest()
{
// Arrange
var request = _fixture.Create<RegistrationRequest>();
var invitation = _fixture.Create<Invitation>();
_invitesServiceMock.Setup(s => s.ValidateAsync(request.InviteLink)).ReturnsAsync(invitation);
_accountServiceMock.Setup(s => s.RegistrationAsync(request.Name, request.Password, invitation))
.ThrowsAsync(new UserAlreadyExistException(request.Name));
// Act
var result = await _controller.Register(request);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
Assert.That(badRequestResult.Value, Is.EqualTo("Registration failed: user already exists."));
}
[Test]
public async Task Register_AccountServiceThrowsGenericException_ReturnsStatusCode500()
{
// Arrange
var request = _fixture.Create<RegistrationRequest>();
var invitation = _fixture.Create<Invitation>();
_invitesServiceMock.Setup(s => s.ValidateAsync(request.InviteLink)).ReturnsAsync(invitation);
_accountServiceMock.Setup(s => s.RegistrationAsync(request.Name, request.Password, invitation))
.ThrowsAsync(new System.Exception("Generic error"));
// Act
var result = await _controller.Register(request);
// Assert
Assert.That(result, Is.InstanceOf<ObjectResult>());
var objectResult = result as ObjectResult;
Assert.That(objectResult.StatusCode, Is.EqualTo(500));
Assert.That(objectResult.Value, Is.EqualTo("An unexpected error occurred. Please try again later."));
}
// Tests for Login action
[Test]
public async Task Login_ValidCredentials_ReturnsOkWithToken()
{
// Arrange
var loginRequest = _fixture.Create<LoginRequest>();
var token = _fixture.Create<RefreshResult>();
var user = _fixture.Build<User>()
.With(x => x.Username).Create();
_accountServiceMock.Setup(l => l.LoginAsync(loginRequest.Name, loginRequest.Password)).ReturnsAsync(user);
_userSessionOpenerMock.Setup(f => f.OpenSessionAsync(user, loginRequest.DeviceInfo))
.ReturnsAsync(token);
// Act
var result = await _controller.Login(loginRequest);
// Assert
Assert.That(result, Is.InstanceOf<OkObjectResult>());
var okResult = result as OkObjectResult;
var response = okResult?.Value as RefreshResult;
Assert.That(response, Is.Not.Null);
Assert.That(response.accessToken, Is.EqualTo(token.accessToken));
Assert.That(response.refreshToken, Is.EqualTo(token.refreshToken));
}
[Test]
public async Task Login_InvalidModelState_ReturnsBadRequest()
{
// Arrange
var request = _fixture.Create<LoginRequest>();
_controller.ModelState.AddModelError("Error", "Sample error");
// Act
var result = await _controller.Login(request);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
[Test]
public async Task Login_UserNotRegistered_ReturnsBadRequest()
{
// Arrange
var request = _fixture.Create<LoginRequest>();
_accountServiceMock.Setup(l => l.LoginAsync(request.Name, request.Password)).Throws(new UserNotRegisteredException(request.Name));
// Act
var result = await _controller.Login(request);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
Assert.That(badRequestResult.Value, Is.EqualTo("Login failed: user does not exist."));
}
[Test]
public async Task Login_PasswordIsIncorrect_ReturnsBadRequest()
{
// Arrange
var request = _fixture.Create<LoginRequest>();
_accountServiceMock.Setup(l => l.LoginAsync(request.Name, request.Password)).Throws(new LoginUserException());
// Act
var result = await _controller.Login(request);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
Assert.That(badRequestResult.Value, Is.EqualTo("Login failed: username or password is incorrect."));
}
[Test]
public async Task Login_AccountServiceThrowsGenericException_ReturnsStatusCode500()
{
// Arrange
var request = _fixture.Create<LoginRequest>();
_accountServiceMock.Setup(s => s.LoginAsync(request.Name, request.Password))
.ThrowsAsync(new System.Exception("Generic error"));
// Act
var result = await _controller.Login(request);
// Assert
Assert.That(result, Is.InstanceOf<ObjectResult>());
var objectResult = result as ObjectResult;
Assert.That(objectResult.StatusCode, Is.EqualTo(500));
Assert.That(objectResult.Value, Is.EqualTo("An unexpected error occurred. Please try again later."));
}
[TearDown]
public void TearDown()
{
(_controller as IDisposable)?.Dispose();
}
}
@@ -1,267 +0,0 @@
using AutoFixture;
using AutoMapper;
using Govor.API.Controllers;
using Govor.Application.Interfaces;
using Govor.Application.Interfaces.Infrastructure.Extensions;
using Govor.Application.Messages;
using Govor.Contracts.Requests;
using Govor.Contracts.Responses;
using Govor.Domain.Models.Messages;
using Govor.Data.Repositories.Exceptions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.API.Tests.IntegrationTests.Controllers;
[TestFixture]
public class ChatLoadControllerTests
{
private Mock<ICurrentUserService> _currentUserServiceMock;
private Mock<ILogger<ChatLoadController>> _loggerMock;
private Mock<IMessagesLoader> _messagesLoaderMock;
private Mock<IMapper> _mapperMock;
private Fixture _fixture;
private ChatLoadController _controller;
private Guid _userId = Guid.NewGuid();
private Guid _chatId = Guid.NewGuid();
private Guid _currentId = Guid.NewGuid();
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors.OfType<ThrowingRecursionBehavior>().ToList().ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_currentUserServiceMock = new Mock<ICurrentUserService>();
_loggerMock = new Mock<ILogger<ChatLoadController>>();
_messagesLoaderMock = new Mock<IMessagesLoader>();
_mapperMock = new Mock<IMapper>();
_currentUserServiceMock.Setup(u => u.GetCurrentUserId()).Returns(_currentId);
_controller = new ChatLoadController(
_loggerMock.Object,
_messagesLoaderMock.Object,
_currentUserServiceMock.Object,
_mapperMock.Object);
}
// Tests for GetChatMessages action
[Test]
public async Task GetChatMessages_ValidRequest_ReturnsOkResult()
{
// Arrange
var random = new Random();
var messages = _fixture.CreateMany<Message>(random.Next(3, 10)).ToList();
var before = random.Next(1, 10);
var after = random.Next(1, 10);
var query = new MessageQuery()
{
Before = before,
After = after,
StartMessageId = null
};
_messagesLoaderMock.Setup(m =>
m.LoadMessagesInChatGroup(_chatId, _currentId, null, before, after))
.ReturnsAsync(messages);
var messagesResponse = messages.Select(m => new MessageResponse()
{
Id = m.Id,
SenderId = m.SenderId,
RecipientId = m.RecipientId,
RecipientType = m.RecipientType,
}).ToList();
_mapperMock.Setup(f => f.Map<List<MessageResponse>>(messages)).
Returns(messagesResponse);
// Act
var result = await _controller.GetGroupMessages(_chatId, query);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.InstanceOf<OkObjectResult>());
var okResult = (OkObjectResult)result;
var values = okResult.Value as List<MessageResponse>;
Assert.That(values, Is.Not.Null);
Assert.That(values.Select(v => v.Id),
Is.EquivalentTo(messagesResponse.Select(m => m.Id)));
Assert.That(values.Select(v => v.SenderId),
Is.EquivalentTo(messagesResponse.Select(m => m.SenderId)));
Assert.That(values.Select(v => v.RecipientId),
Is.EquivalentTo(messagesResponse.Select(m => m.RecipientId)));
Assert.That(values.Select(v => v.RecipientType),
Is.EquivalentTo(messagesResponse.Select(m => m.RecipientType)));
}
[Test]
public async Task GetGroupMessages_InvalidQuery_ReturnsBadRequest()
{
// Arrange
var query = new MessageQuery { Before = -1, After = 10 };
// Act
var result = await _controller.GetGroupMessages(_chatId, query);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
[Test]
public async Task GetGroupMessages_UnauthorizedAccess_ReturnsForbid()
{
// Arrange
var query = new MessageQuery { Before = 10, After = 10 };
_messagesLoaderMock.Setup(m => m.LoadMessagesInChatGroup(It.IsAny<Guid>(), It.IsAny<Guid>(), null, It.IsAny<int>(), It.IsAny<int>()))
.ThrowsAsync(new UnauthorizedAccessException());
// Act
var result = await _controller.GetGroupMessages(_chatId, query);
// Assert
Assert.That(result, Is.InstanceOf<ForbidResult>());
}
[Test]
public async Task GetGroupMessages_NotFound_ReturnsBadRequest()
{
// Arrange
var query = new MessageQuery { Before = 10, After = 10 };
_messagesLoaderMock.Setup(m => m.LoadMessagesInChatGroup(It.IsAny<Guid>(), It.IsAny<Guid>(), null, It.IsAny<int>(), It.IsAny<int>()))
.ThrowsAsync(new NotFoundException("Chat not found"));
// Act
var result = await _controller.GetGroupMessages(_chatId, query);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
[Test]
public async Task GetGroupMessages_ArgumentException_ReturnsBadRequest()
{
// Arrange
var query = new MessageQuery { Before = 10, After = 10 };
_messagesLoaderMock.Setup(m => m.LoadMessagesInChatGroup(It.IsAny<Guid>(), It.IsAny<Guid>(), null, It.IsAny<int>(), It.IsAny<int>()))
.ThrowsAsync(new ArgumentException("Invalid argument"));
// Act
var result = await _controller.GetGroupMessages(_chatId, query);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
// GetUserMessages tests
[Test]
public async Task GetUserMessages_ValidRequest_ReturnsOkResult()
{
// Arrange
var messages = _fixture.CreateMany<Message>(5).ToList();
var query = new MessageQuery { Before = 5, After = 5 };
_messagesLoaderMock.Setup(m => m.LoadMessagesInUserChat(_userId, _currentId, null, 5, 5))
.ReturnsAsync(messages);
var messageResponses = _fixture.CreateMany<MessageResponse>(5).ToList();
_mapperMock.Setup(m => m.Map<List<MessageResponse>>(messages)).Returns(messageResponses);
// Act
var result = await _controller.GetUserMessages(_userId, query);
// Assert
Assert.That(result, Is.InstanceOf<OkObjectResult>());
var okResult = result as OkObjectResult;
Assert.That(okResult.Value, Is.EqualTo(messageResponses));
}
[Test]
public async Task GetUserMessages_InvalidQuery_ReturnsBadRequest()
{
// Arrange
var query = new MessageQuery { Before = -1, After = 10 };
// Act
var result = await _controller.GetUserMessages(_userId, query);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
[Test]
public async Task GetUserMessages_InvalidOperation_ReturnsBadRequest()
{
// Arrange
var query = new MessageQuery { Before = 10, After = 10 };
_messagesLoaderMock.Setup(m => m.LoadMessagesInUserChat(It.IsAny<Guid>(), It.IsAny<Guid>(), null, It.IsAny<int>(), It.IsAny<int>()))
.ThrowsAsync(new InvalidOperationException());
// Act
var result = await _controller.GetUserMessages(_userId, query);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
[Test]
public async Task GetUserMessages_UnauthorizedAccess_ReturnsForbid()
{
// Arrange
var query = new MessageQuery { Before = 10, After = 10 };
_messagesLoaderMock.Setup(m => m.LoadMessagesInUserChat(It.IsAny<Guid>(), It.IsAny<Guid>(), null, It.IsAny<int>(), It.IsAny<int>()))
.ThrowsAsync(new UnauthorizedAccessException());
// Act
var result = await _controller.GetUserMessages(_userId, query);
// Assert
Assert.That(result, Is.InstanceOf<ForbidResult>());
}
[Test]
public async Task GetUserMessages_NotFound_ReturnsBadRequest()
{
// Arrange
var query = new MessageQuery { Before = 10, After = 10 };
_messagesLoaderMock.Setup(m => m.LoadMessagesInUserChat(It.IsAny<Guid>(), It.IsAny<Guid>(), null, It.IsAny<int>(), It.IsAny<int>()))
.ThrowsAsync(new NotFoundException("User not found"));
// Act
var result = await _controller.GetUserMessages(_userId, query);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
[Test]
public async Task GetUserMessages_ArgumentException_ReturnsBadRequest()
{
// Arrange
var query = new MessageQuery { Before = 10, After = 10 };
_messagesLoaderMock.Setup(m => m.LoadMessagesInUserChat(It.IsAny<Guid>(), It.IsAny<Guid>(), null, It.IsAny<int>(), It.IsAny<int>()))
.ThrowsAsync(new ArgumentException("Invalid argument"));
// Act
var result = await _controller.GetUserMessages(_userId, query);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
[TearDown]
public void TearDown()
{
_controller?.Dispose();
}
}
@@ -1,362 +0,0 @@
using System.Text;
using AutoFixture;
using Govor.API.Controllers;
using Govor.Application.Interfaces.Infrastructure.Extensions;
using Govor.Application.Interfaces.Medias;
using Govor.Contracts.Requests;
using Govor.Domain.Models.Messages;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.API.Tests.IntegrationTests.Controllers;
[TestFixture]
public class MediaControllerTests
{
private Fixture _fixture;
private Mock<ICurrentUserService> _currentUserMock;
private Mock<ILogger<MediaController>> _loggerMock;
private Mock<IMediaService> _mockMedia;
private Mock<IAccesserToDownloadMedia> _mockAccesser;
private MediaController _controller;
private Guid _userId = Guid.NewGuid();
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors.OfType<ThrowingRecursionBehavior>().ToList().ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_currentUserMock = new Mock<ICurrentUserService>();
_loggerMock = new Mock<ILogger<MediaController>>();
_mockAccesser = new Mock<IAccesserToDownloadMedia>();
_mockMedia = new Mock<IMediaService>();
_currentUserMock.Setup(f => f.GetCurrentUserId()).Returns(_userId);
_controller = new MediaController(
_loggerMock.Object,
_mockMedia.Object,
_mockAccesser.Object,
_currentUserMock.Object);
}
// Tests for Upload action
[Test]
public async Task Upload_ValidRequest_ReturnsOkResult()
{
// Arrange
var content = "fake file content";
var fileName = "testfile.txt";
var fileBytes = System.Text.Encoding.UTF8.GetBytes(content);
var stream = new MemoryStream(fileBytes);
var formFileMock = new Mock<IFormFile>();
formFileMock.Setup(f => f.Length).Returns(fileBytes.Length);
formFileMock.Setup(f => f.FileName).Returns(fileName);
formFileMock.Setup(f => f.OpenReadStream()).Returns(stream);
formFileMock.Setup(f => f.CopyToAsync(It.IsAny<Stream>(), default))
.Returns<Stream, CancellationToken>((target, _) => stream.CopyToAsync(target));
var uploadRequest = _fixture.Build<MediaUploadRequest>()
.With(r => r.FromFile, formFileMock.Object)
.With(r => r.Type, MediaType.Image)
.With(r => r.MimeType, "image/png")
.With(r => r.EncryptedKey, "secret")
.Create();
var uploadResult = _fixture.Create<MediaUploadResult>();
_mockMedia.Setup(f => f.UploadMediaAsync(It.IsAny<Media>()))
.ReturnsAsync(uploadResult);
// Act
var result = await _controller.Upload(uploadRequest);
// Assert
Assert.That(result, Is.InstanceOf<OkObjectResult>());
var okResult = result as OkObjectResult;
var value = okResult?.Value as MediaUploadResult;
Assert.That(value, Is.Not.Null);
Assert.That(value!.Url, Is.EqualTo(uploadResult.Url));
Assert.That(value.MediaId, Is.EqualTo(uploadResult.MediaId));
}
[Test]
public async Task Upload_InvalidModelState_ReturnsBadRequest()
{
// Arrange
_controller.ModelState.AddModelError("Error", "Invalid model state");
var content = "fake file content";
var fileName = "testfile.txt";
var fileBytes = System.Text.Encoding.UTF8.GetBytes(content);
var stream = new MemoryStream(fileBytes);
var formFileMock = new Mock<IFormFile>();
formFileMock.Setup(f => f.Length).Returns(fileBytes.Length);
formFileMock.Setup(f => f.FileName).Returns(fileName);
formFileMock.Setup(f => f.OpenReadStream()).Returns(stream);
formFileMock.Setup(f => f.CopyToAsync(It.IsAny<Stream>(), default))
.Returns<Stream, CancellationToken>((target, _) => stream.CopyToAsync(target));
var uploadRequest = _fixture.Build<MediaUploadRequest>()
.With(r => r.FromFile, formFileMock.Object)
.With(r => r.Type, MediaType.Image)
.With(r => r.MimeType, "image/png")
.With(r => r.EncryptedKey, "secret")
.Create();
// Act
var result = await _controller.Upload(uploadRequest);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
[Test]
public async Task Upload_NoFileUploaded_ReturnsBadRequest()
{
// Arrange
var uploadRequest = _fixture.Build<MediaUploadRequest>()
.With(r => r.FromFile, (IFormFile)null)
.Create();
// Act
var result = await _controller.Upload(uploadRequest);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
Assert.That(badRequestResult?.Value, Is.EqualTo("No file uploaded"));
}
[Test]
public async Task Upload_EmptyFile_ReturnsBadRequest()
{
// Arrange
var formFileMock = new Mock<IFormFile>();
formFileMock.Setup(f => f.Length).Returns(0);
var uploadRequest = _fixture.Build<MediaUploadRequest>()
.With(r => r.FromFile, formFileMock.Object)
.Create();
// Act
var result = await _controller.Upload(uploadRequest);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
Assert.That(badRequestResult?.Value, Is.EqualTo("No file uploaded"));
}
[Test]
public async Task Upload_FileTooLarge_ReturnsBadRequest()
{
// Arrange
var formFileMock = new Mock<IFormFile>();
formFileMock.Setup(f => f.Length).Returns(20_000_001); // Just over 20MB
var uploadRequest = _fixture.Build<MediaUploadRequest>()
.With(r => r.FromFile, formFileMock.Object)
.Create();
// Act
var result = await _controller.Upload(uploadRequest);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
Assert.That(badRequestResult?.Value, Is.EqualTo("File is too large"));
}
[Test]
public async Task Upload_MissingMimeType_ReturnsBadRequest()
{
// Arrange
var formFileMock = new Mock<IFormFile>();
formFileMock.Setup(f => f.Length).Returns(1000);
formFileMock.Setup(f => f.FileName).Returns("testfile.txt");
var uploadRequest = _fixture.Build<MediaUploadRequest>()
.With(r => r.FromFile, formFileMock.Object)
.With(r => r.MimeType, string.Empty)
.Create();
// Act
var result = await _controller.Upload(uploadRequest);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
Assert.That(badRequestResult?.Value, Is.EqualTo("Missing MIME type"));
}
[Test]
public async Task Upload_UnauthorizedAccess_ReturnsUnauthorized()
{
// Arrange
var formFileMock = new Mock<IFormFile>();
formFileMock.Setup(f => f.Length).Returns(1000);
formFileMock.Setup(f => f.FileName).Returns("testfile.txt");
formFileMock.Setup(f => f.OpenReadStream()).Returns(new MemoryStream(new byte[1000]));
var uploadRequest = _fixture.Build<MediaUploadRequest>()
.With(r => r.FromFile, formFileMock.Object)
.With(r => r.MimeType, "text/plain")
.Create();
_mockMedia.Setup(f => f.UploadMediaAsync(It.IsAny<Media>()))
.ThrowsAsync(new UnauthorizedAccessException("Access denied"));
// Act
var result = await _controller.Upload(uploadRequest);
// Assert
Assert.That(result, Is.InstanceOf<ForbidResult>());
var forbidResult = result as ForbidResult;
Assert.That(forbidResult.AuthenticationSchemes.First(), Is.EqualTo("Access denied"));
}
[Test]
public async Task Upload_InvalidOperation_ReturnsBadRequest()
{
// Arrange
var formFileMock = new Mock<IFormFile>();
formFileMock.Setup(f => f.Length).Returns(1000);
formFileMock.Setup(f => f.FileName).Returns("testfile.txt");
formFileMock.Setup(f => f.OpenReadStream()).Returns(new MemoryStream(new byte[1000]));
var uploadRequest = _fixture.Build<MediaUploadRequest>()
.With(r => r.FromFile, formFileMock.Object)
.With(r => r.MimeType, "text/plain")
.Create();
_mockMedia.Setup(f => f.UploadMediaAsync(It.IsAny<Media>()))
.ThrowsAsync(new InvalidOperationException("Invalid operation"));
// Act
var result = await _controller.Upload(uploadRequest);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
Assert.That(badRequestResult?.Value, Is.EqualTo("Invalid operation"));
}
[Test]
public async Task Upload_GeneralException_ReturnsInternalServerError()
{
// Arrange
var formFileMock = new Mock<IFormFile>();
formFileMock.Setup(f => f.Length).Returns(1000);
formFileMock.Setup(f => f.FileName).Returns("testfile.txt");
formFileMock.Setup(f => f.OpenReadStream()).Returns(new MemoryStream(new byte[1000]));
var uploadRequest = _fixture.Build<MediaUploadRequest>()
.With(r => r.FromFile, formFileMock.Object)
.With(r => r.MimeType, "text/plain")
.Create();
_mockMedia.Setup(f => f.UploadMediaAsync(It.IsAny<Media>()))
.ThrowsAsync(new Exception("Something went wrong"));
// Act
var result = await _controller.Upload(uploadRequest);
// Assert
Assert.That(result, Is.InstanceOf<ObjectResult>());
var objectResult = result as ObjectResult;
Assert.That(objectResult.StatusCode, Is.EqualTo(500));
}
// Tests for Download action
[Test]
public async Task Download_HasAccessAndMediaExists_ReturnsFile()
{
// Arrange
var mediaId = Guid.NewGuid();
var media = _fixture.Build<Media>()
.With(m => m.Data, Encoding.UTF8.GetBytes("fake file content"))
.With(m => m.MimeType, "application/octet-stream") // Ensure MimeType is set
.With(m => m.FileName, "testfile.txt")
.Create();
_mockAccesser.Setup(f => f.HasAccessAsync(mediaId, _userId)).ReturnsAsync(true);
_mockMedia.Setup(f => f.GetMediaByIdAsync(mediaId)).ReturnsAsync(media);
// Act
var result = await _controller.Download(mediaId);
// Assert
Assert.That(result, Is.InstanceOf<FileContentResult>());
var fileResult = result as FileContentResult;
Assert.That(fileResult?.FileContents, Is.EqualTo(media.Data));
Assert.That(fileResult?.ContentType, Is.EqualTo(media.MimeType)); // Changed MineType to MimeType
Assert.That(fileResult?.FileDownloadName, Is.EqualTo(Path.GetFileName(media.FileName)));
}
[Test]
public async Task Download_NoAccess_ReturnsForbid()
{
// Arrange
var mediaId = Guid.NewGuid();
_mockAccesser.Setup(f => f.HasAccessAsync(mediaId, _userId)).ReturnsAsync(false);
// Act
var result = await _controller.Download(mediaId);
// Assert
Assert.That(result, Is.InstanceOf<ForbidResult>());
}
[Test]
public async Task Download_MediaNotFound_ReturnsNotFound()
{
// Arrange
var mediaId = Guid.NewGuid();
_mockAccesser.Setup(f => f.HasAccessAsync(mediaId, _userId)).ReturnsAsync(true);
_mockMedia.Setup(f => f.GetMediaByIdAsync(mediaId))
.ThrowsAsync(new KeyNotFoundException("Media not found"));
// Act
var result = await _controller.Download(mediaId);
// Assert
Assert.That(result, Is.InstanceOf<NotFoundObjectResult>());
var notFoundResult = result as NotFoundObjectResult;
Assert.That(notFoundResult?.Value, Is.EqualTo("Media not found"));
}
[Test]
public async Task Download_GeneralException_ReturnsInternalServerError()
{
// Arrange
var mediaId = Guid.NewGuid();
_mockAccesser.Setup(f => f.HasAccessAsync(mediaId, _userId)).ReturnsAsync(true);
_mockMedia.Setup(f => f.GetMediaByIdAsync(mediaId))
.ThrowsAsync(new Exception("Something went wrong"));
// Act
var result = await _controller.Download(mediaId);
// Assert
Assert.That(result, Is.InstanceOf<ObjectResult>());
var objectResult = result as ObjectResult;
Assert.That(objectResult.StatusCode, Is.EqualTo(500));
}
[TearDown]
public void TearDown()
{
_controller.Dispose();
}
}
@@ -1,124 +0,0 @@
using AutoFixture;
using Govor.API.Controllers.Authentication;
using Govor.Application.Interfaces.UserSession;
using Govor.Contracts.Requests;
using Govor.Contracts.Responses;
using Microsoft.AspNetCore.Identity.Data;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.API.Tests.IntegrationTests.Controllers;
[TestFixture]
public class RefreshControllerTests
{
private Fixture _fixture;
private Mock<ILogger<RefreshController>> _mockLogger;
private Mock<IUserSessionRefresher> _mockSessionRefresher;
private RefreshController _controller;
private RefreshTokenRequest _request;
private RefreshResult _result;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_mockLogger = new Mock<ILogger<RefreshController>>();
_mockSessionRefresher = new Mock<IUserSessionRefresher>();
_request = _fixture.Create<RefreshTokenRequest>();
_result = _fixture.Create<RefreshResult>();
_controller = new RefreshController(_mockLogger.Object, _mockSessionRefresher.Object);
}
// Tests for Refresh action
[Test]
public async Task Refresh_ValidRequest_ReturnsOkResult()
{
// Arrange
_mockSessionRefresher.Setup(f => f.RefreshTokenAsync(_request.RefreshToken))
.ReturnsAsync(_result);
// Act
var result = await _controller.Refresh(_request);
//Assert
Assert.That(result, Is.InstanceOf<OkObjectResult>());
var okResult = result as OkObjectResult;
var response = okResult?.Value as RefreshTokenResponse;
Assert.That(response, Is.Not.Null);
Assert.That(response.AccessToken, Is.EqualTo(_result.accessToken));
Assert.That(response.RefreshToken, Is.EqualTo(_result.refreshToken));
}
[Test]
public async Task Refresh_InvalidModelState_ReturnsBadRequest()
{
// Arrange
_controller.ModelState.AddModelError("Error", "Sample error");
// Act
var result = await _controller.Refresh(_request);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
[Test]
public async Task Refresh_InvalidRefreshToken_ReturnsBadRequest()
{
// Arrange
_request.RefreshToken = string.Empty;
// Act
var result = await _controller.Refresh(_request);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
var badRequestResult = result as BadRequestObjectResult;
var response = badRequestResult?.Value;
Assert.That(response, Is.EqualTo("Refresh token cant be empty."));
}
[Test]
public async Task Refresh_UnauthorizedAccessException_ReturnsUnauthorizedRequest()
{
// Arrange
_mockSessionRefresher.Setup(f => f.RefreshTokenAsync(_request.RefreshToken))
.ThrowsAsync(new UnauthorizedAccessException());
// Act
var result = await _controller.Refresh(_request);
// Assert
Assert.That(result, Is.InstanceOf<UnauthorizedObjectResult>());
var unauthorized = result as UnauthorizedObjectResult;
var response = unauthorized?.Value;
Assert.That(response, Is.EqualTo("Invalid refresh token"));
}
[Test]
public async Task Refresh_InvalidOperationException_ReturnsBadRequest()
{
// Arrange
_mockSessionRefresher.Setup(f => f.RefreshTokenAsync(_request.RefreshToken))
.ThrowsAsync(new InvalidOperationException());
// Act
var result = await _controller.Refresh(_request);
// Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>());
}
[TearDown]
public void TearDown()
{
_controller?.Dispose();
}
}
@@ -1,57 +0,0 @@
using AutoFixture;
using Govor.API.Common.SignalR.Helpers;
using Govor.API.Hubs;
using Govor.Application.Interfaces;
using Govor.Application.Interfaces.Messages;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.API.Tests.IntegrationTests.Hubs;
[TestFixture]
public class ChatsHubTests
{
/*
private Mock<ILogger<ChatsHub>> _loggerMock;
private Mock<IMessageCommandService> _messageServiceMock;
private Mock<IUserGroupsGetterService> _userGroupsServiceMock;
private Mock<IHubUserAccessor> _hubUserAccessorMock;
private Fixture _fixture;
private ChatsHub _chatsHub;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors.OfType<ThrowingRecursionBehavior>().ToList().ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_messageServiceMock = new Mock<IMessageCommandService>();
_userGroupsServiceMock = new Mock<IUserGroupsGetterService>();
_loggerMock = new Mock<ILogger<ChatsHub>>();
_hubUserAccessorMock = new Mock<IHubUserAccessor>();
_chatsHub = new ChatsHub(
_loggerMock.Object,
_messageServiceMock.Object,
_userGroupsServiceMock.Object,
_hubUserAccessorMock.Object
);
}
// Test for Send action
[Test]
public void SendMessage_Success()
{
}
[TearDown]
public void TearDown()
{
_chatsHub?.Dispose();
}
*/
}
@@ -1,118 +0,0 @@
using AutoFixture;
using Govor.Domain.Common.Constants;
using Govor.Domain.Models;
namespace Govor.API.Tests.UnitTests.Infrastructure.Validators;
[TestFixture]
public class ChatGroupValidatorTests
{
private IObjectValidator<ChatGroup> _validator = new ChatGroupValidator();
private Fixture _fixture;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors
.OfType<ThrowingRecursionBehavior>()
.ToList()
.ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
}
[Test]
public void Validate_ChatGroup_Valid()
{
// Arrange
var chat = _fixture.Create<ChatGroup>();
// Act & Assert
Assert.DoesNotThrow(() => _validator.Validate(chat));
Assert.That(_validator.TryValidate(chat), Is.True);
}
[Test]
public void Validate_ChatGroupIsNull_Invalid()
{
// Act & Assert
Assert.Throws<InvalidObjectException<ChatGroup>>(() => _validator.Validate(default));
Assert.That(_validator.TryValidate(default), Is.False);
}
[Test]
public void Validate_ChatGroupIdIsEmpty_Invalid()
{
// Arrange
var chat = _fixture.Create<ChatGroup>();
chat.Id = Guid.Empty;
// Act & Assert
Assert.Throws<InvalidObjectException<ChatGroup>>(() => _validator.Validate(chat));
Assert.That(_validator.TryValidate(chat), Is.False);
}
[Test]
public void Validate_ChatGroupNameIsEmpty_Invalid()
{
// Arrange
var chat = _fixture.Create<ChatGroup>();
chat.Name = "";
// Act & Assert
Assert.Throws<InvalidObjectException<ChatGroup>>(() => _validator.Validate(chat));
Assert.That(_validator.TryValidate(chat), Is.False);
}
[Test]
public void Validate_ChatGroupDescriptionIsNull_Invalid()
{
// Arrange
var chat = _fixture.Create<ChatGroup>();
chat.Description = default;
// Act & Assert
Assert.Throws<InvalidObjectException<ChatGroup>>(() => _validator.Validate(chat));
Assert.That(_validator.TryValidate(chat), Is.False);
}
[Test]
public void Validate_ChatGroupImageIdIsEmpty_Invalid()
{
// Arrange
var chat = _fixture.Create<ChatGroup>();
chat.ImageId = Guid.Empty;
// Act & Assert
Assert.Throws<InvalidObjectException<ChatGroup>>(() => _validator.Validate(chat));
Assert.That(_validator.TryValidate(chat), Is.False);
}
[Test]
public void Validate_ChatGroupIsPrivateAndInvitesCodesIsEmpty_Invalid()
{
// Arrange
var chat = _fixture.Create<ChatGroup>();
chat.IsPrivate = true;
chat.InviteCodes = new();
// Act & Assert
Assert.Throws<InvalidObjectException<ChatGroup>>(() => _validator.Validate(chat));
Assert.That(_validator.TryValidate(chat), Is.False);
}
[Test]
public void Validate_ChatGroupAdminsIsEmpty_Invalid()
{
// Arrange
var chat = _fixture.Create<ChatGroup>();
chat.Admins = new();
// Act & Assert
Assert.Throws<InvalidObjectException<ChatGroup>>(() => _validator.Validate(chat));
Assert.That(_validator.TryValidate(chat), Is.False);
}
}
@@ -1,86 +0,0 @@
using AutoFixture;
using Govor.Domain.Common.Constants;
using Govor.Domain.Models;
namespace Govor.API.Tests.UnitTests.Infrastructure.Validators;
[TestFixture]
public class FriendshipValidatorTests
{
private IObjectValidator<Friendship> _friendshipValidator;
private Fixture _fixture;
public FriendshipValidatorTests()
{
_friendshipValidator = new FriendshipValidator();
_fixture = new Fixture();
_fixture.Behaviors
.OfType<ThrowingRecursionBehavior>()
.ToList()
.ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
}
[Test]
public void Given_ValidFriendship_When_Validate_Then_Returns_True()
{
// Arrange
var friendship = _fixture.Create<Friendship>();
// Act & Assert
Assert.DoesNotThrow( () => _friendshipValidator.Validate(friendship));
Assert.That(_friendshipValidator.TryValidate(friendship), Is.True);
}
[Test]
public void Given_EmptyFriendshipId_When_Validate_Then_Returns_False()
{
// Arrange
var friendship = _fixture.Create<Friendship>();
friendship.Id = Guid.Empty;
// Act & Assert
Assert.Throws<InvalidObjectException<Friendship>>( () => _friendshipValidator.Validate(friendship));
Assert.That(_friendshipValidator.TryValidate(friendship), Is.False);
}
[Test]
public void Given_EmptyRequesterId_When_Validate_Then_Returns_False()
{
// Arrange
var friendship = _fixture.Create<Friendship>();
friendship.RequesterId = Guid.Empty;
// Act & Assert
Assert.Throws<InvalidObjectException<Friendship>>( () => _friendshipValidator.Validate(friendship));
Assert.That(_friendshipValidator.TryValidate(friendship), Is.False);
}
[Test]
public void GivenSameRequesterId_When_Validate_Then_Returns_False()
{
// Arrange
var friendship = _fixture.Create<Friendship>();
friendship.RequesterId = friendship.AddresseeId;
// Act & Assert
Assert.Throws<InvalidObjectException<Friendship>>( () => _friendshipValidator.Validate(friendship));
Assert.That(_friendshipValidator.TryValidate(friendship), Is.False);
}
[Test]
public void Given_AddresseeId_When_Validate_Then_Returns_False()
{
// Arrange
var friendship = _fixture.Create<Friendship>();
friendship.AddresseeId = Guid.Empty;
// Act & Assert
Assert.Throws<InvalidObjectException<Friendship>>( () => _friendshipValidator.Validate(friendship));
Assert.That(_friendshipValidator.TryValidate(friendship), Is.False);
}
}
@@ -1,105 +0,0 @@
using AutoFixture;
using Govor.Domain.Common.Constants;
using Govor.Domain.Models;
namespace Govor.API.Tests.UnitTests.Infrastructure.Validators;
[TestFixture]
public class InvitationConstantsTests
{
private IObjectValidator<Invitation> _messageValidator;
private Fixture _fixture;
public InvitationConstantsTests()
{
_messageValidator = new InvitationConstants();
_fixture = new Fixture();
_fixture.Behaviors
.OfType<ThrowingRecursionBehavior>()
.ToList()
.ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
}
[Test]
public void Given_ValidInvitation_When_Validate_Then_Returns_True()
{
var invitation = _fixture.Create<Invitation>();
// Act & Assert
Assert.DoesNotThrow( () => _messageValidator.Validate(invitation));
Assert.That(_messageValidator.TryValidate(invitation), Is.True);
}
[Test]
public void Given_NullInvitation_When_Validate_Then_Returns_False()
{
// Act & Assert
Assert.Throws<InvalidObjectException<Invitation>>( () => _messageValidator.Validate(default));
Assert.That(_messageValidator.TryValidate(default), Is.False);
}
[Test]
public void Given_EmptyInvitationId_When_Validate_Then_Returns_False()
{
// Arrange
var invitation = _fixture.Create<Invitation>();
invitation.Id = Guid.Empty;
// Act & Assert
Assert.Throws<InvalidObjectException<Invitation>>( () => _messageValidator.Validate(invitation));
Assert.That(_messageValidator.TryValidate(invitation), Is.False);
}
[Test]
public void Given_EmptyInvitationCreationDate_When_Validate_Then_Returns_False()
{
// Arrange
var invitation = _fixture.Create<Invitation>();
invitation.DateCreated = DateTime.MinValue;
// Act & Assert
Assert.Throws<InvalidObjectException<Invitation>>( () => _messageValidator.Validate(invitation));
Assert.That(_messageValidator.TryValidate(invitation), Is.False);
}
[Test]
public void Given_InvalidEndDatesAndIsActive_When_Validate_Then_Returns_False()
{
// Arrange
var invitation = _fixture.Create<Invitation>();
invitation.EndDate = invitation.DateCreated.AddDays(-1);
invitation.IsActive = true;
// Act & Assert
Assert.Throws<InvalidObjectException<Invitation>>( () => _messageValidator.Validate(invitation));
Assert.That(_messageValidator.TryValidate(invitation), Is.False);
}
[Test]
public void Given_InvalidMaxParticipantsAndIsActive_When_Validate_Then_Returns_False()
{
// Arrange
var invitation = _fixture.Create<Invitation>();
invitation.MaxParticipants = new Random().Next(-5, 0);
invitation.IsActive = true;
// Act & Assert
Assert.Throws<InvalidObjectException<Invitation>>( () => _messageValidator.Validate(invitation));
Assert.That(_messageValidator.TryValidate(invitation), Is.False);
}
[Test]
public void Given_InvalidCode_When_Validate_Then_Returns_False()
{
// Arrange
var invitation = _fixture.Create<Invitation>();
invitation.Code = string.Empty;
// Act & Assert
Assert.Throws<InvalidObjectException<Invitation>>( () => _messageValidator.Validate(invitation));
Assert.That(_messageValidator.TryValidate(invitation), Is.False);
}
}
@@ -1,134 +0,0 @@
using AutoFixture;
using Govor.Domain.Common.Constants;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
namespace Govor.API.Tests.UnitTests.Infrastructure.Validators;
[TestFixture]
public class MessageValidatorTests
{
private IObjectValidator<Message> _messageValidator;
private Fixture _fixture;
public MessageValidatorTests()
{
_messageValidator = new MessageValidator();
_fixture = new Fixture();
_fixture.Behaviors
.OfType<ThrowingRecursionBehavior>()
.ToList()
.ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
}
[Test]
public void Given_NullMessage_When_Validate_Should_Throw_InvalidObjectException()
{
// Act & Assert
Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(default));
}
[Test]
public void Given_NullMessage_When_TryValidate_Then_Returns_False()
{
// Act & Assert
Assert.That(_messageValidator.TryValidate(default), Is.False);
}
[Test]
public void Given_EmptyIdMessage_When_Validate_Should_Throw_InvalidObjectException()
{
// Arrange
Message message = _fixture.Create<Message>();
message.Id = Guid.Empty;
// Act & Assert
Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
Assert.That(_messageValidator.TryValidate(message), Is.False);
}
[Test]
public void Given_EmptySenderIdMessage_When_Validate_Should_Throw_InvalidObjectException()
{
// Arrange
Message message = _fixture.Create<Message>();
message.SenderId = Guid.Empty;
// Act & Assert
Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
Assert.That(_messageValidator.TryValidate(message), Is.False);
}
[Test]
public void Given_EmptyRecipientIdMessage_When_Validate_Should_Throw_InvalidObjectException()
{
// Arrange
Message message = _fixture.Create<Message>();
message.RecipientId = Guid.Empty;
// Act & Assert
Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
Assert.That(_messageValidator.TryValidate(message), Is.False);
}
[Test]
public void Given_EmptyEncryptedMessageAndNotEmptyMedia_When_Validate_Should_Throw_InvalidObjectException()
{
// Arrange
Message message = _fixture.Create<Message>();
message.EncryptedContent = string.Empty;
Assert.DoesNotThrowAsync(async () => _messageValidator.Validate(message));
Assert.That(_messageValidator.TryValidate(message), Is.True);
}
[Test]
public void Given_EmptyEncryptedMessageAndEmptyMedia_When_Validate_Should_Throw_InvalidObjectException()
{
// Arrange
Message message = _fixture.Create<Message>();
message.EncryptedContent = string.Empty;
message.MediaAttachments = default;
Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
Assert.That(_messageValidator.TryValidate(message), Is.False);
}
[Test]
public void Given_IsEditAndEmptyEditeTimeMessage_When_Validate_Should_Throw_InvalidObjectException()
{
// Arrange
Message message = _fixture.Create<Message>();
message.IsEdited = true;
message.EditedAt = DateTime.MinValue;
Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
Assert.That(_messageValidator.TryValidate(message), Is.False);
}
[Test]
public void Given_EmptySentAtMessage_When_Validate_Should_Throw_InvalidObjectException()
{
// Arrange
Message message = _fixture.Create<Message>();
message.SentAt = DateTime.MinValue;
Assert.ThrowsAsync<InvalidObjectException<Message>>(async () => _messageValidator.Validate(message));
Assert.That(_messageValidator.TryValidate(message), Is.False);
}
[Test]
public void Given_ValidMessage_When_Validate_Then_Should_NotThrow()
{
// Arrange
Message message = _fixture.Create<Message>();
// Act & Assert
Assert.DoesNotThrowAsync(async () => _messageValidator.Validate(message));
Assert.That(_messageValidator.TryValidate(message), Is.True);
}
}
@@ -1,77 +0,0 @@
using AutoFixture;
using Govor.Domain.Common.Constants;
using Govor.Domain.Models;
namespace Govor.API.Tests.UnitTests.Infrastructure.Validators;
[TestFixture]
public class PrivateChatValidatorTests
{
private IObjectValidator<PrivateChat> _validator = new PrivateChatValidator();
private Fixture _fixture;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors
.OfType<ThrowingRecursionBehavior>()
.ToList()
.ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
}
[Test]
public void Validate_PrivateChat_Valid()
{
// Arrange
var privateChat = _fixture.Create<PrivateChat>();
// Act & Assert
Assert.DoesNotThrow(() => _validator.Validate(privateChat));
Assert.That(_validator.TryValidate(privateChat), Is.True);
}
[Test]
public void Validate_When_PrivateChatIsNull_Invalid()
{
// Act & Assert
Assert.Throws<InvalidObjectException<PrivateChat>>(() => _validator.Validate(default));
Assert.That(_validator.TryValidate(default), Is.False);
}
[Test]
public void Validate_When_PrivateChatIdIsEmpty_Invalid()
{
// Arrange
var privateChat = _fixture.Create<PrivateChat>();
privateChat.Id = Guid.Empty;
// Act & Assert
Assert.Throws<InvalidObjectException<PrivateChat>>(() => _validator.Validate(privateChat));
Assert.That(_validator.TryValidate(privateChat), Is.False);
}
[Test]
public void Validate_When_UserAIdIsEmpty_Invalid()
{
// Arrange
var privateChat = _fixture.Create<PrivateChat>();
privateChat.UserAId = Guid.Empty;
// Act & Assert
Assert.Throws<InvalidObjectException<PrivateChat>>(() => _validator.Validate(privateChat));
Assert.That(_validator.TryValidate(privateChat), Is.False);
}
[Test]
public void Validate_When_UserBIdIsEmpty_Invalid()
{
// Arrange
var privateChat = _fixture.Create<PrivateChat>();
privateChat.UserBId = Guid.Empty;
// Act & Assert
Assert.Throws<InvalidObjectException<PrivateChat>>(() => _validator.Validate(privateChat));
Assert.That(_validator.TryValidate(privateChat), Is.False);
}
}
@@ -1,170 +0,0 @@
using AutoFixture;
using Govor.Domain.Common.Constants;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
namespace Govor.API.Tests.UnitTests.Infrastructure.Validators;
[TestFixture]
public class UserConstantsTests
{
private IObjectValidator<User> _userValidator;
private Fixture _fixture;
[SetUp]
public void SetUp()
{
_userValidator = new UserConstants();
_fixture = new Fixture();
_fixture.Behaviors
.OfType<ThrowingRecursionBehavior>()
.ToList()
.ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
}
[Test]
public void Given_NullUser_ShouldThrow_InvalidObjectException()
{
// Act & Assert
Assert.ThrowsAsync<InvalidObjectException<User>>(async () => _userValidator.Validate(default));
}
[Test]
public void Given_NullUser_Then_Returns_False()
{
// Act & Assert
Assert.That(_userValidator.TryValidate(default), Is.False);
}
[Test]
public void Given_EmptyId_ShouldThrow_InvalidObjectException()
{
// Arrange
User user = new User()
{
PasswordHash = _fixture.Create<string>(),
Username = _fixture.Create<string>(),
Id = Guid.Empty,
CreatedOn = DateOnly.FromDateTime(DateTime.Now),
};
// Act & Assert
Assert.ThrowsAsync<InvalidObjectException<User>>(async () => _userValidator.Validate(user));
}
[Test]
public void Given_EmptyId_Then_Returns_False()
{
// Arrange
User user = new User()
{
PasswordHash = _fixture.Create<string>(),
Username = _fixture.Create<string>(),
Id = Guid.Empty,
CreatedOn = DateOnly.FromDateTime(DateTime.Now),
};
// Act & Assert
Assert.That(_userValidator.TryValidate(user), Is.False);
}
[Test]
public void Given_EmptyPassword_ShouldThrow_InvalidObjectException()
{
// Arrange
User user = new User()
{
PasswordHash = string.Empty,
Username = _fixture.Create<string>(),
Id = Guid.NewGuid(),
CreatedOn = DateOnly.FromDateTime(DateTime.Now),
};
// Act & Assert
Assert.ThrowsAsync<InvalidObjectException<User>>(async () => _userValidator.Validate(user));
}
[Test]
public void Given_EmptyPassword_Then_Returns_False()
{
// Arrange
User user = new User()
{
PasswordHash = string.Empty,
Username = _fixture.Create<string>(),
Id = Guid.NewGuid(),
CreatedOn = DateOnly.FromDateTime(DateTime.Now),
};
// Act & Assert
Assert.That(_userValidator.TryValidate(user), Is.False);
}
[Test]
public void Given_EmptyName_ShouldThrow_InvalidObjectException()
{
// Arrange
User user = new User()
{
PasswordHash = _fixture.Create<string>(),
Username = String.Empty,
Id = Guid.NewGuid(),
CreatedOn = DateOnly.FromDateTime(DateTime.Now),
};
// Act & Assert
Assert.ThrowsAsync<InvalidObjectException<User>>(async () => _userValidator.Validate(user));
}
[Test]
public void Given_EmptyName_Then_Returns_False()
{
// Arrange
User user = new User()
{
PasswordHash = _fixture.Create<string>(),
Username = String.Empty,
Id = Guid.NewGuid(),
CreatedOn = DateOnly.FromDateTime(DateTime.Now),
};
// Act & Assert
Assert.That(_userValidator.TryValidate(user), Is.False);
}
[Test]
public void Given_ValidUser_ShouldNotThrow_InvalidObjectException()
{
// Arrange
User user = new User()
{
PasswordHash = _fixture.Create<string>(),
Username = _fixture.Create<string>(),
Id = Guid.NewGuid(),
CreatedOn = DateOnly.FromDateTime(DateTime.Now),
};
// Act & Assert
Assert.DoesNotThrowAsync(async () => _userValidator.Validate(user));
}
[Test]
public void Given_ValidUser_Then_Returns_True()
{
// Arrange
User user = new User()
{
PasswordHash = _fixture.Create<string>(),
Username = _fixture.Create<string>(),
Id = Guid.NewGuid(),
CreatedOn = DateOnly.FromDateTime(DateTime.Now),
};
// Act & Assert
Assert.That(_userValidator.TryValidate(user), Is.True);
}
}
+1 -1
View File
@@ -65,7 +65,7 @@ public class MediaController : Controller
fileBytes, fileBytes,
request.Type, request.Type,
request.MimeType, request.MimeType,
request.EncryptedKey, request.EncryptedKey ?? string.Empty,
request.OwnerType, request.OwnerType,
null) null)
{ {
@@ -1,35 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<LangVersion>latest</LangVersion>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="AutoFixture" Version="5.0.0-preview0012" />
<PackageReference Include="coverlet.collector" Version="6.0.2" />
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.6" />
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.0.6" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
<PackageReference Include="Moq" Version="4.20.72" />
<PackageReference Include="NUnit" Version="4.4.0-beta.1" />
<PackageReference Include="NUnit.Analyzers" Version="4.4.0"/>
<PackageReference Include="NUnit3TestAdapter" Version="4.6.0"/>
</ItemGroup>
<ItemGroup>
<Using Include="NUnit.Framework"/>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Govor.Application\Govor.Application.csproj" />
</ItemGroup>
<ItemGroup>
<Folder Include="Validators\" />
</ItemGroup>
</Project>
@@ -1,89 +0,0 @@
using AutoFixture;
using Govor.Application.Infrastructure.AdminsStuff;
using Govor.Application.Interfaces;
using Govor.Domain.Models;
using Govor.Domain.Repositories.Invaites;
using Moq;
namespace Govor.Application.Tests.Infrastructure.AdminsStuff;
[TestFixture]
public class InvitationGeneratorTests
{
private Fixture _fixture;
private Mock<IInvitesRepository> _invitesRepositoryMock;
private IInvitationGenerator _invitationGenerator;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors.OfType<ThrowingRecursionBehavior>().ToList().ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_invitesRepositoryMock = new Mock<IInvitesRepository>();
_invitationGenerator = new InvitationGenerator(_invitesRepositoryMock.Object);
}
[Test]
public async Task GenerateInvitationCode_ShouldReturnNonEmptyString_WhenCalled()
{
// Arrange
var endDate = _fixture.Create<DateTime>();
var maxUsers = _fixture.Create<int>();
var isAdmin = _fixture.Create<bool>();
var description = _fixture.Create<string>();
// Act
var code = await _invitationGenerator.GenerateInvitationCode(endDate, maxUsers, isAdmin, description);
// Assert
Assert.That(code, Is.Not.Null.And.Not.Empty);
}
[Test]
public async Task GenerateInvitationCode_ShouldCallAddAsyncOnRepository_WithCorrectInvitation()
{
// Arrange
var endDate = DateTime.UtcNow.AddDays(7); // Specific date for easier assertion if needed
var maxUsers = 10;
var isAdmin = false;
var description = "Test Invitation";
Invitation capturedInvitation = null;
_invitesRepositoryMock.Setup(repo => repo.AddAsync(It.IsAny<Invitation>()))
.Callback<Invitation>(inv => capturedInvitation = inv)
.Returns(Task.CompletedTask);
// Act
var code = await _invitationGenerator.GenerateInvitationCode(endDate, maxUsers, isAdmin, description);
// Assert
_invitesRepositoryMock.Verify(repo => repo.AddAsync(It.IsAny<Invitation>()), Times.Once);
Assert.That(capturedInvitation, Is.Not.Null);
Assert.That(capturedInvitation.EndDate.ToUniversalTime(), Is.EqualTo(endDate.ToUniversalTime()));
Assert.That(capturedInvitation.MaxParticipants, Is.EqualTo(maxUsers));
Assert.That(capturedInvitation.IsAdmin, Is.EqualTo(isAdmin));
Assert.That(capturedInvitation.Description, Is.EqualTo(description));
Assert.That(capturedInvitation.Code, Is.EqualTo(code));
Assert.That(capturedInvitation.IsActive, Is.True); // Assuming new invitations are active by default
}
[Test]
public async Task GenerateInvitationCode_ShouldGenerateUniqueCode_WhenCalled()
{
// Arrange
var endDate = _fixture.Create<DateTime>();
var maxUsers = _fixture.Create<int>();
var isAdmin = _fixture.Create<bool>();
var description = _fixture.Create<string>();
// Act
var code1 = await _invitationGenerator.GenerateInvitationCode(endDate, maxUsers, isAdmin, description);
var code2 = await _invitationGenerator.GenerateInvitationCode(endDate, maxUsers, isAdmin, description);
// Assert
Assert.That(code1, Is.Not.EqualTo(code2));
}
}
@@ -1,102 +0,0 @@
using AutoFixture;
using Govor.Domain.Infrastructure.Extensions;
using Govor.Domain.Models;
using Govor.Domain.Repositories.Users;
using Govor.Application.Authentication.Exceptions;
using Govor.Application.Interfaces.Authentication;
using Govor.Application.Services.Authentication;
using Govor.Domain.Models.Users;
using Govor.Domain.Repositories.Admins;
using Moq;
namespace Govor.Application.Tests.Services.Authentication;
[TestFixture]
public class AuthServiceTests
{
private Fixture _fixture;
private Mock<IPasswordHasher> _passwordHasherMock;
private Mock<IJwtService> _jwtServiceMock;
private Mock<IUsersRepository> _usersRepositoryMock;
private Mock<IAdminsRepository> _adminsRepositoryMock;
private Mock<IUsernameValidator> _usernameValidatorMock;
private IAccountService _accountService;
[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>();
_passwordHasherMock = new Mock<IPasswordHasher>();
_jwtServiceMock = new Mock<IJwtService>();
_adminsRepositoryMock = new Mock<IAdminsRepository>();
_usernameValidatorMock = new Mock<IUsernameValidator>();
_accountService = new AuthService(
_usersRepositoryMock.Object,
_passwordHasherMock.Object,
_adminsRepositoryMock.Object,
_usernameValidatorMock.Object
);
}
// Tests for Register action
[Test]
public void Given_ExistUser_When_Register_Should_Throw_UserAlreadyExistsException()
{
// Arrange
_usersRepositoryMock.Setup(r => r.ExistsUsernameAsync(It.IsAny<string>())).ReturnsAsync(true);
// Act & Assert
Assert.ThrowsAsync<UserAlreadyExistException>(async () => await _accountService.RegistrationAsync(
_fixture.Create<string>(), _fixture.Create<string>(), _fixture.Create<Invitation>()));
}
[Test]
public void Given_NotExistUser_When_Register_Should_Dont_Throw_UserNotRegisteredException()
{
// Arrange
_usersRepositoryMock.Setup(r => r.ExistsUsernameAsync(It.IsAny<string>())).ReturnsAsync(false);
// Act & Assert
Assert.DoesNotThrowAsync(async () => await _accountService.RegistrationAsync(
_fixture.Create<string>(), _fixture.Create<string>(), _fixture.Create<Invitation>()));
}
[Test]
public void Given_WrongPassword_When_Login_Should_Throw_LoginUserException()
{
// Arrange
_usersRepositoryMock.Setup(r => r.ExistsUsernameAsync(It.IsAny<string>())).ReturnsAsync(true);
_passwordHasherMock.Setup(h => h.Verify(It.IsAny<string>(),
It.IsAny<string>())).Returns(false);
_usersRepositoryMock.Setup(u => u.FindByUsernameAsync(It.IsAny<string>()))
.ReturnsAsync(() => _fixture.Create<User>());
// Act & Assert
Assert.ThrowsAsync<LoginUserException>(async () => await _accountService.LoginAsync(
_fixture.Create<string>(), _fixture.Create<string>()));
}
[Test]
public void Given_NotExistUser_When_Login_Should_Throw_UserNotRegisteredException()
{
// Arrange
_usersRepositoryMock.Setup(r => r.ExistsUsernameAsync(It.IsAny<string>())).ReturnsAsync(false);
// Act & Assert
Assert.ThrowsAsync<UserNotRegisteredException>(async () => await _accountService.LoginAsync(
_fixture.Create<string>(), _fixture.Create<string>()));
}
}
@@ -1,313 +0,0 @@
using AutoFixture;
using Govor.Application.Exceptions.FriendsService;
using Govor.Application.Interfaces;
using Govor.Application.Interfaces.Friends;
using Govor.Application.PrivateUserChats;
using Govor.Application.Services.Friends;
using Govor.Domain.Models;
using Govor.Domain.Repositories.Friendships;
using Govor.Domain.Repositories.Users;
using Govor.Data.Repositories.Exceptions;
using Moq;
namespace Govor.Application.Tests.Services.Friends;
[TestFixture]
public class FriendRequestCommandServiceTests
{
private Fixture _fixture;
private Mock<IFriendshipsRepository> _friendshipsRepositoryMock;
private Mock<IUserPrivateChatsCreator> _privateChatsCreatorMock;
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());
_friendshipsRepositoryMock = new Mock<IFriendshipsRepository>();
_privateChatsCreatorMock = new Mock<IUserPrivateChatsCreator>();
_service = new FriendRequestCommandService(_friendshipsRepositoryMock.Object, _privateChatsCreatorMock.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();
var existingFriendship = new Friendship
{
Id = Guid.NewGuid(),
RequesterId = fromUserId,
AddresseeId = toUserId,
Status = FriendshipStatus.Pending
};
_friendshipsRepositoryMock
.Setup(repo => repo.GetFriendshipAsync(fromUserId, toUserId))
.ReturnsAsync(existingFriendship);
// 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_AndCreatesPrivateChat()
{
// Arrange
var friendship = _fixture.Build<Friendship>()
.With(f => f.Status, FriendshipStatus.Pending)
.Create();
var privateChat = new PrivateChat
{
Id = Guid.NewGuid(),
UserAId = friendship.AddresseeId,
UserBId = friendship.RequesterId
};
_friendshipsRepositoryMock
.Setup(r => r.GetByIdAsync(friendship.Id))
.ReturnsAsync(friendship);
_privateChatsCreatorMock
.Setup(p => p.CreateAsync(friendship.AddresseeId, friendship.RequesterId))
.ReturnsAsync(privateChat);
// Act
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);
_privateChatsCreatorMock.Verify(p => p.CreateAsync(
friendship.AddresseeId,
friendship.RequesterId
), 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));
}
}
@@ -1,131 +0,0 @@
using AutoFixture;
using Govor.Application.Interfaces.Friends;
using Govor.Application.Services.Friends;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Govor.Domain.Repositories.Friendships;
using Govor.Domain.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));
}
}
@@ -1,162 +0,0 @@
using AutoFixture;
using Govor.Application.Interfaces.Friends;
using Govor.Application.Services.Friends;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Govor.Domain.Repositories.Friendships;
using Govor.Domain.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 async Task SearchUsersAsync_Returns_EmptyList_IfThrowsNotFoundByKeyException_String_Guid()
{
// Arrange
_usersRepositoryMock
.Setup(u => u.SearchPotentialFriendsAsync(It.IsAny<Guid>(), It.IsAny<string>()))
.ThrowsAsync(new NotFoundByKeyException<(string,Guid)>(("test",Guid.NewGuid()),"test"));
// Act
var users = await _service.SearchUsersAsync("test", Guid.NewGuid());
// & Assert
Assert.That(users, Is.Empty);
}
[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
_usersRepositoryMock
.Setup(u => u.SearchPotentialFriendsAsync(It.IsAny<Guid>(), "test"))
.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()));
}
}
@@ -1,294 +0,0 @@
using Govor.Application.Services.Medias;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Govor.Data;
using Microsoft.EntityFrameworkCore;
namespace Govor.Application.Tests.Services.Medias;
[TestFixture]
public class AccesserToDownloadMediaServiceTests
{
private GovorDbContext _dbContext = null!;
private AccesserToDownloadMediaService _accesser = null!;
private Guid _userId;
private Guid _otherUserId;
private Guid _groupId;
private Guid _mediaFileId;
[SetUp]
public async Task SetUp()
{
var options = new DbContextOptionsBuilder<GovorDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
_dbContext = new GovorDbContext(options);
_accesser = new AccesserToDownloadMediaService(_dbContext);
_userId = Guid.NewGuid();
_otherUserId = Guid.NewGuid();
_groupId = Guid.NewGuid();
_mediaFileId = Guid.NewGuid();
// ������� ��������� � �����
var message = new Message
{
Id = Guid.NewGuid(),
SenderId = _userId,
RecipientId = _otherUserId,
RecipientType = RecipientType.User
};
var media = new MediaFile
{
Id = _mediaFileId,
Url = "/media/test.png",
MineType = "image/png",
MediaType = MediaType.Image,
UploaderId = _userId,
DateCreated = DateTime.UtcNow,
OwnerType = MediaOwnerType.Message,
OwnerId = message.Id
};
var attachment = new MediaAttachments
{
Id = Guid.NewGuid(),
MediaFileId = _mediaFileId,
MessageId = message.Id,
Message = message,
MediaFile = media
};
await _dbContext.Messages.AddAsync(message);
await _dbContext.MediaFiles.AddAsync(media);
await _dbContext.MediaAttachments.AddAsync(attachment);
await _dbContext.SaveChangesAsync();
}
[Test]
public async Task HasAccessAsync_ReturnsTrue_ForSender()
{
var result = await _accesser.HasAccessAsync(_mediaFileId, _userId);
Assert.That(result, Is.True);
}
[Test]
public async Task HasAccessAsync_ReturnsTrue_ForRecipient()
{
var result = await _accesser.HasAccessAsync(_mediaFileId, _otherUserId);
Assert.That(result, Is.True);
}
[Test]
public async Task HasAccessAsync_ReturnsFalse_ForUnrelatedUser()
{
var unrelatedUserId = Guid.NewGuid();
var result = await _accesser.HasAccessAsync(_mediaFileId, unrelatedUserId);
Assert.That(result, Is.False);
}
[Test]
public async Task HasAccessAsync_ReturnsTrue_ForGroupMember()
{
var groupMediaId = Guid.NewGuid();
var groupMessage = new Message
{
Id = Guid.NewGuid(),
SenderId = _userId,
RecipientId = _groupId,
RecipientType = RecipientType.Group
};
var media = new MediaFile
{
Id = groupMediaId,
Url = "/media/group.png",
MineType = "image/png",
MediaType = MediaType.Image,
UploaderId = _userId,
DateCreated = DateTime.UtcNow,
OwnerType = MediaOwnerType.Message,
OwnerId = groupMessage.Id
};
var attachment = new MediaAttachments
{
Id = Guid.NewGuid(),
MediaFileId = groupMediaId,
MessageId = groupMessage.Id,
Message = groupMessage,
MediaFile = media
};
var membership = new GroupMembership
{
Id = Guid.NewGuid(),
GroupId = _groupId,
UserId = _otherUserId
};
await _dbContext.Messages.AddAsync(groupMessage);
await _dbContext.MediaFiles.AddAsync(media);
await _dbContext.MediaAttachments.AddAsync(attachment);
await _dbContext.GroupMemberships.AddAsync(membership);
await _dbContext.SaveChangesAsync();
var result = await _accesser.HasAccessAsync(groupMediaId, _otherUserId);
Assert.That(result, Is.True);
}
[Test]
public async Task HasAccessAsync_ReturnsFalse_IfMediaNotAttached()
{
var result = await _accesser.HasAccessAsync(Guid.NewGuid(), _userId);
Assert.That(result, Is.False);
}
[Test]
public async Task HasAccessAsync_ReturnsTrue_ForUserAvatar()
{
var avatarMedia = new MediaFile
{
Id = Guid.NewGuid(),
Url = "/media/avatar.png",
MineType = "image/png",
MediaType = MediaType.Image,
UploaderId = _userId,
OwnerType = MediaOwnerType.Avatar,
OwnerId = _userId,
DateCreated = DateTime.UtcNow
};
await _dbContext.MediaFiles.AddAsync(avatarMedia);
await _dbContext.SaveChangesAsync();
var result = await _accesser.HasAccessAsync(avatarMedia.Id, _userId);
Assert.That(result, Is.True);
}
[Test]
public async Task HasAccessAsync_ReturnsTrue_ForOtherUserAvatar()
{
var avatarMedia = new MediaFile
{
Id = Guid.NewGuid(),
Url = "/media/avatar2.png",
MineType = "image/png",
MediaType = MediaType.Image,
UploaderId = _otherUserId,
OwnerType = MediaOwnerType.Avatar,
OwnerId = _otherUserId,
DateCreated = DateTime.UtcNow
};
await _dbContext.MediaFiles.AddAsync(avatarMedia);
await _dbContext.SaveChangesAsync();
var result = await _accesser.HasAccessAsync(avatarMedia.Id, _userId);
Assert.That(result, Is.True);
}
[Test]
public async Task HasAccessAsync_ReturnsTrue_ForGroupAvatarMember()
{
var groupAvatar = new MediaFile
{
Id = Guid.NewGuid(),
Url = "/media/group_avatar.png",
MineType = "image/png",
MediaType = MediaType.Image,
UploaderId = _userId,
OwnerType = MediaOwnerType.GroupAvatar,
OwnerId = _groupId,
DateCreated = DateTime.UtcNow
};
var membership = new GroupMembership
{
Id = Guid.NewGuid(),
GroupId = _groupId,
UserId = _otherUserId
};
await _dbContext.MediaFiles.AddAsync(groupAvatar);
await _dbContext.GroupMemberships.AddAsync(membership);
await _dbContext.SaveChangesAsync();
var result = await _accesser.HasAccessAsync(groupAvatar.Id, _otherUserId);
Assert.That(result, Is.True);
}
[Test]
public async Task HasAccessAsync_ReturnsFalse_ForGroupAvatarNonMember()
{
var groupAvatar = new MediaFile
{
Id = Guid.NewGuid(),
Url = "/media/group_avatar2.png",
MineType = "image/png",
MediaType = MediaType.Image,
UploaderId = _userId,
OwnerType = MediaOwnerType.GroupAvatar,
OwnerId = _groupId,
DateCreated = DateTime.UtcNow
};
await _dbContext.MediaFiles.AddAsync(groupAvatar);
await _dbContext.SaveChangesAsync();
var unrelatedUserId = Guid.NewGuid();
var result = await _accesser.HasAccessAsync(groupAvatar.Id, unrelatedUserId);
Assert.That(result, Is.False);
}
[Test]
public async Task HasAccessAsync_ReturnsTrue_ForSystemMedia()
{
var systemMedia = new MediaFile
{
Id = Guid.NewGuid(),
Url = "/media/system.png",
MineType = "image/png",
MediaType = MediaType.Image,
UploaderId = _userId,
OwnerType = MediaOwnerType.System,
DateCreated = DateTime.UtcNow
};
await _dbContext.MediaFiles.AddAsync(systemMedia);
await _dbContext.SaveChangesAsync();
var result = await _accesser.HasAccessAsync(systemMedia.Id, Guid.NewGuid());
Assert.That(result, Is.True);
}
[Test]
public async Task HasAccessAsync_ReturnsFalse_ForUnknownOwnerType()
{
var unknownMedia = new MediaFile
{
Id = Guid.NewGuid(),
Url = "/media/unknown.png",
MineType = "image/png",
MediaType = MediaType.Image,
UploaderId = _userId,
OwnerType = (MediaOwnerType)999, // ����������� ���
DateCreated = DateTime.UtcNow
};
await _dbContext.MediaFiles.AddAsync(unknownMedia);
await _dbContext.SaveChangesAsync();
var result = await _accesser.HasAccessAsync(unknownMedia.Id, _userId);
Assert.That(result, Is.False);
}
[TearDown]
public void TearDown()
{
_dbContext.Dispose();
}
}
@@ -1,359 +0,0 @@
using Govor.Application.Exceptions.VerifyFriendship;
using Govor.Application.Interfaces;
using Govor.Application.Interfaces.Medias;
using Govor.Application.Interfaces.Messages.Parameters;
using Govor.Application.PrivateUserChats;
using Govor.Application.Services.Messages;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Govor.Domain.Repositories.Groups;
using Govor.Domain.Repositories.Messages;
using Govor.Domain.Repositories.PrivateChats;
using Govor.Domain.Repositories.Users;
using Govor.Data.Repositories.Exceptions;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.Application.Tests.Services.Messages;
[TestFixture]
public class MessageCommandServiceTests
{
private Mock<IMessagesRepository> _mockMessagesRepo;
private Mock<IUsersRepository> _mockUsersRepo;
private Mock<IGroupsRepository> _mockGroupsRepo;
private Mock<IPrivateChatsRepository> _mockPrivateChatsRepo;
private Mock<IVerifyFriendship> _mockVerifyFriendship;
private Mock<IMediaService> _mockMediaService;
private Mock<IUserPrivateChatsCreator> _mockUserPrivateChatCreator;
private Mock<ILogger<MessageCommandService>> _mockLogger;
private MessageCommandService _messageService;
[SetUp]
public void SetUp()
{
_mockMessagesRepo = new Mock<IMessagesRepository>();
_mockUsersRepo = new Mock<IUsersRepository>();
_mockGroupsRepo = new Mock<IGroupsRepository>();
_mockPrivateChatsRepo = new Mock<IPrivateChatsRepository>();
_mockVerifyFriendship = new Mock<IVerifyFriendship>();
_mockMediaService = new Mock<IMediaService>();
_mockUserPrivateChatCreator = new Mock<IUserPrivateChatsCreator>();
_mockLogger = new Mock<ILogger<MessageCommandService>>();
_messageService = new MessageCommandService(
_mockMessagesRepo.Object,
_mockUsersRepo.Object,
_mockGroupsRepo.Object,
_mockPrivateChatsRepo.Object,
_mockUserPrivateChatCreator.Object,
_mockVerifyFriendship.Object,
_mockMediaService.Object,
_mockLogger.Object);
}
// Test for SendMessageAsync action
[Test]
public async Task SendMessageAsync_ToUser_Success()
{
// Arrange
var senderId = Guid.NewGuid();
var recipientId = Guid.NewGuid();
var privateChat = new PrivateChat
{
Id = recipientId,
UserAId = senderId,
UserBId = Guid.NewGuid()
};
var sendParams = new SendMessage(
"Hello",
null,
recipientId,
RecipientType.User,
senderId,
DateTime.UtcNow,
new List<SendMedia>());
_mockPrivateChatsRepo
.Setup(r => r.GetByIdAsync(recipientId))
.ReturnsAsync(privateChat);
_mockMessagesRepo
.Setup(r => r.AddAsync(It.IsAny<Message>()))
.Returns(Task.CompletedTask);
// Act
var result = await _messageService.SendMessageAsync(sendParams);
// Assert
Assert.That(result.IsSuccess, Is.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_ToUser_When_AttachMediaThrowsException_ReturnsFailure()
{
// Arrange
var senderId = Guid.NewGuid();
var recipientId = Guid.NewGuid();
var sendMediaId = Guid.NewGuid();
var privateChat = new PrivateChat
{
Id = recipientId,
UserAId = senderId,
UserBId = recipientId
};
var sendParams = new SendMessage(
"Hello",
null,
recipientId,
RecipientType.User,
senderId,
DateTime.UtcNow,
new List<SendMedia>
{
new SendMedia(sendMediaId, string.Empty)
});
_mockPrivateChatsRepo
.Setup(r => r.GetByIdAsync(recipientId))
.ReturnsAsync(privateChat);
_mockMediaService
.Setup(m => m.AttachToMessageAsync(sendMediaId, It.IsAny<Guid>()))
.ThrowsAsync(new Exception("Unexpected DB error"));
// Act
var result = await _messageService.SendMessageAsync(sendParams);
// Assert
Assert.That(result.IsSuccess, Is.False);
Assert.That(result.Exception!.Message, Is.EqualTo("Unexpected DB error"));
_mockMessagesRepo.Verify(r => r.AddAsync(It.IsAny<Message>()), Times.Never);
}
[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.Exist(groupId)).Returns(true);
_mockGroupsRepo.Setup(r => r.IsUserMemberOfGroupAsync(senderId, groupId)).ReturnsAsync(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.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_PrivateChatNotFound_ReturnsFailure()
{
// Arrange
var senderId = Guid.NewGuid();
var recipientId = Guid.NewGuid();
var sendParams = new SendMessage(
"Hello",
null,
recipientId,
RecipientType.User,
senderId,
DateTime.UtcNow,
new List<SendMedia>());
_mockPrivateChatsRepo
.Setup(r => r.GetByIdAsync(recipientId))
.ReturnsAsync((PrivateChat?)null);
// Act
var result = await _messageService.SendMessageAsync(sendParams);
// Assert
Assert.That(result.IsSuccess, Is.False);
Assert.That(result.Exception, Is.TypeOf<KeyNotFoundException>());
Assert.That(result.Message, Is.Null);
}
// 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.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.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.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.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.False);
Assert.That(result.Exception, Is.Not.Null);
Assert.That(result.Exception,Is.TypeOf<KeyNotFoundException>());
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.False);
Assert.That(result.Exception, Is.Not.Null);
Assert.That(result.Exception,Is.TypeOf<UnauthorizedAccessException>());
Assert.That(result.OriginalMessage, Is.Null);
}
}
@@ -1,184 +0,0 @@
using Govor.Application.Interfaces;
using Govor.Application.Messages;
using Govor.Application.Services.Messages;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Govor.Domain.Repositories.Groups;
using Govor.Domain.Repositories.PrivateChats;
using Govor.Data;
using Microsoft.EntityFrameworkCore;
using Moq;
namespace Govor.Application.Tests.Services.Messages;
[TestFixture]
public class MessagesLoaderTests
{
private IMessagesLoader _loader;
private Mock<IPrivateChatsRepository> _privateChatsRepoMock;
private Mock<IGroupsRepository> _groupsRepoMock;
private GovorDbContext _dbContext;
private Guid _currentUserId = Guid.NewGuid();
private Guid _otherUserId = Guid.NewGuid();
private Guid _groupChatId = Guid.NewGuid();
[SetUp]
public void Setup()
{
_privateChatsRepoMock = new Mock<IPrivateChatsRepository>();
_groupsRepoMock = new Mock<IGroupsRepository>();
var options = new DbContextOptionsBuilder<GovorDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
_dbContext = new GovorDbContext(options);
_loader = new MessagesLoader(_groupsRepoMock.Object, _privateChatsRepoMock.Object, _dbContext);
}
// Tests for LoadLastMessagesInUserChat action
[Test]
public async Task LoadLastMessagesInUserChat_ReturnsMessages_WhenChatExists()
{
// Arrange
var chatId = Guid.NewGuid();
_privateChatsRepoMock
.Setup(r => r.Exist(chatId))
.Returns(true);
var messages = new List<Message>
{
new()
{
Id = Guid.NewGuid(),
RecipientId = chatId,
RecipientType = RecipientType.User,
SentAt = DateTime.UtcNow
}
};
await _dbContext.Messages.AddRangeAsync(messages);
await _dbContext.SaveChangesAsync();
// Act
var result = await _loader.LoadMessagesInUserChat(
chatId,
_currentUserId,
null);
// Assert
Assert.That(result, Has.Count.EqualTo(1));
}
[Test]
public async Task LoadLastMessagesInUserChat_ReturnsEmpty_WhenNoMessages()
{
// Arrange
var chatId = Guid.NewGuid();
_privateChatsRepoMock
.Setup(r => r.Exist(chatId))
.Returns(true);
// Act
var result = await _loader.LoadMessagesInUserChat(
chatId,
_currentUserId,
null);
// Assert
Assert.That(result, Is.Empty);
}
[Test]
public void LoadLastMessagesInUserChat_Throws_WhenUserIdIsEmpty()
{
// Act & Assert
var ex = Assert.ThrowsAsync<ArgumentException>(async () =>
await _loader.LoadMessagesInUserChat(Guid.Empty, _currentUserId, null));
Assert.That(ex.Message, Does.Contain("PrivateChatId id cannot be empty"));
}
[Test]
public void LoadLastMessagesInUserChat_Throws_WhenChatNotExists()
{
// Arrange
_privateChatsRepoMock.Setup(r => r.Exist(It.IsAny<Guid>(), It.IsAny<Guid>())).Returns(false);
// Act & Assert
var ex = Assert.ThrowsAsync<InvalidOperationException>(async () =>
await _loader.LoadMessagesInUserChat(_currentUserId, _otherUserId, null));
Assert.That(ex.Message, Is.EqualTo("Private chat not found"));
}
// Tests for LoadLastMessagesInChatGroup action
[Test]
public async Task LoadLastMessagesInChatGroup_ReturnsMessages_WhenUserIsMember()
{
// Arrange
_groupsRepoMock.Setup(g => g.IsUserMemberOfGroupAsync(_currentUserId, _groupChatId))
.ReturnsAsync(true);
var messages = new List<Message>
{
new() { Id = Guid.NewGuid(), RecipientId = _groupChatId, RecipientType = RecipientType.Group }
};
await _dbContext.Messages.AddRangeAsync(messages);
await _dbContext.SaveChangesAsync();
// Act
var result = await _loader.LoadMessagesInChatGroup(_groupChatId, _currentUserId, null);
// Assert
Assert.That(result, Has.Count.EqualTo(1));
}
[Test]
public void LoadLastMessagesInChatGroup_Throws_WhenChatIdEmpty()
{
// Act & Assert
var ex = Assert.ThrowsAsync<ArgumentException>(async () =>
await _loader.LoadMessagesInChatGroup(Guid.Empty, _currentUserId, null));
Assert.That(ex.Message, Is.EqualTo("Chat id cannot be empty"));
}
[Test]
public void LoadLastMessagesInChatGroup_Throws_WhenUserNotInGroup()
{
// Arrange
_groupsRepoMock.Setup(g => g.IsUserMemberOfGroupAsync(_currentUserId, _groupChatId))
.ReturnsAsync(false);
// Act & Assert
var ex = Assert.ThrowsAsync<UnauthorizedAccessException>(async () =>
await _loader.LoadMessagesInChatGroup(_groupChatId, _currentUserId, null));
Assert.That(ex.Message, Is.EqualTo("You are not a member of this group."));
}
[Test]
public async Task LoadLastMessagesInChatGroup_ReturnsEmpty_WhenNoMessages()
{
// Arrange
_groupsRepoMock.Setup(g => g.IsUserMemberOfGroupAsync(_currentUserId, _groupChatId))
.ReturnsAsync(true);
// Act
var result = await _loader.LoadMessagesInChatGroup(_groupChatId, _currentUserId, null);
// Assert
Assert.That(result, Is.Empty);
}
[TearDown]
public void TearDown()
{
_dbContext.Dispose();
}
}
@@ -1,65 +0,0 @@
using Govor.Application.PingHandler;
using Govor.Domain.Models.Users;
using Govor.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;
namespace Govor.Application.Tests.Services;
[TestFixture]
public class PingHandlerServiceTests
{
private GovorDbContext _dbContext = null!;
private IMemoryCache _memoryCache = null!;
private PingHandlerService _service = null!;
private Guid _userId;
[SetUp]
public void SetUp()
{
var options = new DbContextOptionsBuilder<GovorDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
_dbContext = new GovorDbContext(options);
_memoryCache = new MemoryCache(new MemoryCacheOptions());
_service = new PingHandlerService(_dbContext, _memoryCache);
_userId = Guid.NewGuid();
_dbContext.Users.Add(new User
{
Id = _userId,
Username = "TestUser",
WasOnline = DateTime.UtcNow.AddHours(-1),
Description = "Test description",
PasswordHash = "hashed_password_here"
});
_dbContext.SaveChanges();
}
[Test]
public async Task Ping_DoesNotUpdate_WhenPingTooRecent()
{
// Arrange
var initial = DateTime.UtcNow.AddMinutes(-1);
_memoryCache.Set($"LastPing_{_userId}", DateTime.UtcNow);
var user = await _dbContext.Users.FirstAsync(u => u.Id == _userId);
var originalTime = user.WasOnline;
// Act
await _service.Ping(_userId);
var updatedUser = await _dbContext.Users.FirstAsync(u => u.Id == _userId);
// Assert
Assert.That(updatedUser.WasOnline, Is.EqualTo(originalTime));
}
[TearDown]
public void TearDown()
{
_dbContext?.Dispose();
_memoryCache?.Dispose();
}
}
@@ -1,143 +0,0 @@
using Govor.Domain.Models.Users;
using Govor.Domain.Repositories.Users;
using Govor.Data.Repositories.Exceptions;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.Application.Tests.Services;
[TestFixture]
public class ProfileServiceTests
{
private Mock<IUsersRepository> _mockUsersRepo = null!;
private Mock<ILogger<ProfileService>> _mockLogger = null!;
private ProfileService _service = null!;
private User _testUser = null!;
[SetUp]
public void SetUp()
{
_mockUsersRepo = new Mock<IUsersRepository>();
_mockLogger = new Mock<ILogger<ProfileService>>();
_service = new ProfileService(_mockUsersRepo.Object, _mockLogger.Object);
_testUser = new User
{
Id = Guid.NewGuid(),
Username = "testuser",
Description = "old description",
IconId = Guid.NewGuid()
};
}
// ---------- GetUserProfileAsync ----------
[Test]
public async Task GetUserProfileAsync_ReturnsCorrectData()
{
// Arrange
_mockUsersRepo.Setup(r => r.FindByIdAsync(_testUser.Id))
.ReturnsAsync(_testUser);
// Act
var result = await _service.GetUserProfileAsync(_testUser.Id);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Id, Is.EqualTo(_testUser.Id));
Assert.That(result.Username, Is.EqualTo("testuser"));
Assert.That(result.Description, Is.EqualTo("old description"));
Assert.That(result.IconId, Is.EqualTo(_testUser.IconId));
_mockUsersRepo.Verify(r => r.FindByIdAsync(_testUser.Id), Times.Once);
}
[Test]
public void GetUserProfileAsync_Throws_WhenUserNotFound()
{
// Arrange
_mockUsersRepo.Setup(r => r.FindByIdAsync(It.IsAny<Guid>()))
.ReturnsAsync((User)null!);
// Act + Assert
Assert.ThrowsAsync<NullReferenceException>(() =>
_service.GetUserProfileAsync(Guid.NewGuid()));
}
[Test]
public void GetUserProfileAsync_ThrowsNotFoundException_WhenNotFoundByKeyException()
{
// Arrange
var userId = Guid.NewGuid();
_mockUsersRepo.Setup(r => r.FindByIdAsync(It.IsAny<Guid>()))
.ThrowsAsync(new NotFoundByKeyException<Guid>(userId));
// Act + Assert
Assert.ThrowsAsync<NotFoundException>(() =>
_service.GetUserProfileAsync(userId));
}
// ---------- SetDescription ----------
[Test]
public async Task SetDescription_UpdatesUserDescription()
{
// Arrange
var newDescription = "new cool description";
_mockUsersRepo.Setup(r => r.FindByIdAsync(_testUser.Id))
.ReturnsAsync(_testUser);
_mockUsersRepo.Setup(r => r.UpdateAsync(It.IsAny<User>()))
.Returns(Task.CompletedTask);
// Act
await _service.SetDescription(newDescription, _testUser.Id);
// Assert
Assert.That(_testUser.Description, Is.EqualTo(newDescription));
_mockUsersRepo.Verify(r => r.UpdateAsync(It.Is<User>(u => u.Description == newDescription)), Times.Once);
}
[Test]
public void SetDescription_Throws_WhenUserNotFound()
{
// Arrange
_mockUsersRepo.Setup(r => r.FindByIdAsync(It.IsAny<Guid>()))
.ReturnsAsync((User)null!);
// Act + Assert
Assert.ThrowsAsync<NullReferenceException>(() =>
_service.SetDescription("desc", Guid.NewGuid()));
}
// ---------- SetNewIcon ----------
[Test]
public async Task SetNewIcon_UpdatesUserIconId()
{
// Arrange
var newIconId = Guid.NewGuid();
_mockUsersRepo.Setup(r => r.FindByIdAsync(_testUser.Id))
.ReturnsAsync(_testUser);
_mockUsersRepo.Setup(r => r.UpdateAsync(It.IsAny<User>()))
.Returns(Task.CompletedTask);
// Act
await _service.SetNewIcon(_testUser.Id, newIconId);
// Assert
Assert.That(_testUser.IconId, Is.EqualTo(newIconId));
_mockUsersRepo.Verify(r => r.UpdateAsync(It.Is<User>(u => u.IconId == newIconId)), Times.Once);
}
[Test]
public void SetNewIcon_Throws_WhenUserNotFound()
{
// Arrange
_mockUsersRepo.Setup(r => r.FindByIdAsync(It.IsAny<Guid>()))
.ReturnsAsync((User)null!);
// Act + Assert
Assert.ThrowsAsync<NullReferenceException>(() =>
_service.SetNewIcon(Guid.NewGuid(), Guid.NewGuid()));
}
}
@@ -1,184 +0,0 @@
using Govor.Application.Interfaces.PushNotifications;
using Govor.Application.Interfaces.PushNotifications.Models;
using Govor.Application.PushNotifications;
using Govor.Application.Services.PushNotifications;
using Govor.Domain.Repositories.PushTokens;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.Application.Tests.Services.PushNotifications;
[TestFixture]
public class PushNotificationServiceTests
{
private Mock<IPushNotificationProvider> _providerMock;
private Mock<IPushTokenRepository> _tokenRepoMock;
private Mock<ILogger<PushNotificationService>> _loggerMock;
private PushNotificationService _service;
[SetUp]
public void Setup()
{
_providerMock = new Mock<IPushNotificationProvider>(MockBehavior.Strict);
_tokenRepoMock = new Mock<IPushTokenRepository>(MockBehavior.Strict);
_loggerMock = new Mock<ILogger<PushNotificationService>>();
_service = new PushNotificationService(
_providerMock.Object,
_tokenRepoMock.Object,
_loggerMock.Object);
}
#region SendToUserAsync
[Test]
public async Task SendToUserAsync_NoTokens_DoesNotCallProvider()
{
// Arrange
var userId = Guid.NewGuid();
_tokenRepoMock
.Setup(r => r.GetActiveTokensAsync(userId))
.ReturnsAsync(new List<string>());
// Act
await _service.SendToUserAsync(userId, "title", "body", "chat");
// Assert
_providerMock.Verify(
p => p.SendMulticastAsync(It.IsAny<IReadOnlyList<string>>(), It.IsAny<PushMessage>()),
Times.Never);
}
[Test]
public async Task SendToUserAsync_SuccessfulSend_CallsProvider()
{
// Arrange
var userId = Guid.NewGuid();
var tokens = new List<string> { "t1", "t2" };
_tokenRepoMock
.Setup(r => r.GetActiveTokensAsync(userId))
.ReturnsAsync(tokens);
_providerMock
.Setup(p => p.SendMulticastAsync(tokens, It.IsAny<PushMessage>()))
.ReturnsAsync(new SendPushResult(0, 0, []));
// Act
await _service.SendToUserAsync(userId, "title", "body", "chat");
// Assert
_providerMock.Verify(
p => p.SendMulticastAsync(tokens, It.IsAny<PushMessage>()),
Times.Once);
_tokenRepoMock.Verify(
r => r.RemoveTokensAsync(It.IsAny<IEnumerable<string>>()),
Times.Never);
}
[Test]
public async Task SendToUserAsync_WithFailures_RemovesInvalidTokens()
{
// Arrange
var userId = Guid.NewGuid();
var tokens = new List<string> { "t1", "t2" };
var failed = new List<string> { "t2" };
_tokenRepoMock
.Setup(r => r.GetActiveTokensAsync(userId))
.ReturnsAsync(tokens);
_providerMock
.Setup(p => p.SendMulticastAsync(tokens, It.IsAny<PushMessage>()))
.ReturnsAsync(new SendPushResult(0, 1, failed));
_tokenRepoMock
.Setup(r => r.RemoveTokensAsync(failed))
.Returns(Task.CompletedTask);
// Act
await _service.SendToUserAsync(userId, "title", "body", "chat");
// Assert
_tokenRepoMock.Verify(r => r.RemoveTokensAsync(failed), Times.Once);
}
#endregion
#region SendToUsersAsync
[Test]
public async Task SendToUsersAsync_NoTokens_DoesNotCallProvider()
{
// Arrange
var users = new[] { Guid.NewGuid() };
_tokenRepoMock
.Setup(r => r.GetActiveTokensUsersAsync(users))
.ReturnsAsync(new List<string>());
// Act
await _service.SendToUsersAsync(users, "title", "body", "chat");
// Assert
_providerMock.Verify(
p => p.SendMulticastAsync(It.IsAny<IReadOnlyList<string>>(), It.IsAny<PushMessage>()),
Times.Never);
}
#endregion
#region SendToSessionAsync
[Test]
public async Task SendToSessionAsync_NoToken_DoesNothing()
{
// Arrange
var sessionId = Guid.NewGuid();
_tokenRepoMock
.Setup(r => r.GetActiveTokenBySessionAsync(sessionId))
.ReturnsAsync("");
// Act
await _service.SendToSessionAsync(sessionId, "title", "body", "chat");
// Assert
_providerMock.Verify(
p => p.SendToTokenAsync(It.IsAny<string>(), It.IsAny<PushMessage>()),
Times.Never);
}
[Test]
public async Task SendToSessionAsync_WithFailure_RemovesToken()
{
// Arrange
var sessionId = Guid.NewGuid();
var token = "t1";
_tokenRepoMock
.Setup(r => r.GetActiveTokenBySessionAsync(sessionId))
.ReturnsAsync(token);
_providerMock
.Setup(p => p.SendToTokenAsync(token, It.IsAny<PushMessage>()))
.ReturnsAsync(new SendPushResult(0, 1, [token]));
_tokenRepoMock
.Setup(r => r.RemoveTokensAsync(It.IsAny<IEnumerable<string>>()))
.Returns(Task.CompletedTask);
// Act
await _service.SendToSessionAsync(sessionId, "title", "body", "chat");
// Assert
_tokenRepoMock.Verify(
r => r.RemoveTokensAsync(It.Is<IEnumerable<string>>(x => x.Contains(token))),
Times.Once);
}
#endregion
}
@@ -1,70 +0,0 @@
using AutoFixture;
using Govor.Application.Groups;
using Govor.Application.Interfaces;
using Govor.Domain.Models;
using Govor.Domain.Repositories.Groups;
using Govor.Data.Repositories.Exceptions;
using Moq;
namespace Govor.Application.Tests.Services;
[TestFixture]
public class UserGroupsGetterServiceTests
{
private Fixture _fixture;
private Mock<IGroupsRepository> _repositoryMock;
private IUserGroupsGetterService _getterService;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors
.OfType<ThrowingRecursionBehavior>()
.ToList()
.ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_repositoryMock = new Mock<IGroupsRepository>();
_getterService = new UserGroupsGetterService(_repositoryMock.Object);
}
[Test]
public async Task GetUserGroups_ShouldReturnAllUserGroups()
{
// Arrange
var chats = _fixture.CreateMany<ChatGroup>();
var userId = chats.First().Members.First().Id;
_repositoryMock.Setup(r => r.GetByUserIdAsync(userId))
.ReturnsAsync([chats.First()]);
// Act
var result = await _getterService.GetUserGroupsAsync(userId);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count(), Is.EqualTo(1));
Assert.That(result, Is.EquivalentTo([chats.First()]));
}
[Test]
public async Task GetUserGroups_ButGroupDoesNotExist_ShouldReturnEmptyList()
{
// Arrange
var userId = _fixture.Create<Guid>();
_repositoryMock.Setup(r => r.GetByUserIdAsync(userId))
.ThrowsAsync(new NotFoundByKeyException<Guid>(userId));
// Act
var result = await _getterService.GetUserGroupsAsync(userId);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count(), Is.EqualTo(0));
}
}
@@ -1,83 +0,0 @@
using Govor.Application.Interfaces.UserOnlineStatus;
using Govor.Application.Services.UserOnlineStatus;
namespace Govor.Application.Tests.Services.UserOnlineStatus;
[TestFixture]
public class OnlineUserStoreTests
{
/*
private IOnlineUserStore _store;
private Guid _userId1;
private Guid _userId2;
[SetUp]
public void Setup()
{
_store = new OnlineUserStore();
_userId1 = Guid.NewGuid();
_userId2 = Guid.NewGuid();
}
[Test]
public void SetOnlineUser_UserIsMarkedOnline()
{
// Act
_store.SetOnlineUser(_userId1);
// Assert
Assert.That(_store.IsOnline(_userId1), Is.True);
}
[Test]
public void SetOfflineUser_UserIsNoLongerOnline()
{
// Act
_store.SetOnlineUser(_userId1);
_store.SetOfflineUser(_userId1);
// Assert
Assert.That(_store.IsOnline(_userId1), Is.False);
}
[Test]
public void IsOnline_ReturnsFalse_ForUnknownUser()
{
// Act & Assert
Assert.That(_store.IsOnline(Guid.NewGuid()), Is.False);
}
[Test]
public void GetAllOnlineUsers_ReturnsAllCurrentlyOnlineUsers()
{
// Arrange
_store.SetOnlineUser(_userId1);
_store.SetOnlineUser(_userId2);
// Act
var onlineUsers = _store.GetAllOnlineUsers();
// Assert
Assert.That(onlineUsers, Is.EquivalentTo(new[] { _userId1, _userId2 }));
}
[Test]
public void SetOnlineUser_Twice_DoesNotThrow()
{
// Act & Assert
Assert.DoesNotThrow(() =>
{
_store.SetOnlineUser(_userId1);
_store.SetOnlineUser(_userId1);
});
Assert.That(_store.IsOnline(_userId1), Is.True);
}
[Test]
public void SetOfflineUser_ForUnknownUser_DoesNotThrow()
{
// Act & Assert
Assert.DoesNotThrow(() => _store.SetOfflineUser(Guid.NewGuid()));
}*/
}
@@ -1,108 +0,0 @@
using AutoFixture;
using Govor.Application.Interfaces;
using Govor.Application.PrivateUserChats;
using Govor.Domain.Models;
using Govor.Domain.Repositories.PrivateChats;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.Application.Tests.Services;
[TestFixture]
public class UserPrivateChatsCreatorTests
{
private Fixture _fixture;
private Mock<ILogger<UserPrivateChatsCreator>> _mockLogger;
private Mock<IPrivateChatsRepository> _mockPrivateChats;
private Mock<IPrivateChatGroupManager> _mockPrivateChatGroupManager;
private IUserPrivateChatsCreator _service;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors
.OfType<ThrowingRecursionBehavior>()
.ToList()
.ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_mockLogger = new Mock<ILogger<UserPrivateChatsCreator>>();
_mockPrivateChats = new Mock<IPrivateChatsRepository>();
_mockPrivateChatGroupManager = new Mock<IPrivateChatGroupManager>();
_service = new UserPrivateChatsCreator(
_mockPrivateChats.Object,
_mockPrivateChatGroupManager.Object,
_mockLogger.Object);
}
[Test]
public async Task CreateAsync_ShouldCreateNewChat_WhenChatDoesNotExist()
{
// Arrange
var userA = Guid.NewGuid();
var userB = Guid.NewGuid();
_mockPrivateChats
.Setup(x => x.Exist(userA, userB))
.Returns(false);
PrivateChat? addedChat = null;
_mockPrivateChats
.Setup(x => x.AddAsync(It.IsAny<PrivateChat>()))
.Callback<PrivateChat>(chat => addedChat = chat)
.Returns(Task.CompletedTask);
// Act
var result = await _service.CreateAsync(userA, userB);
// Assert
_mockPrivateChats.Verify(x => x.AddAsync(It.IsAny<PrivateChat>()), Times.Once);
_mockPrivateChatGroupManager.Verify(x => x.AddUsersToPrivateChatGroupAsync(It.IsAny<PrivateChat>()), Times.Once);
Assert.That(result, Is.Not.Null);
Assert.That(result.UserAId, Is.EqualTo(userA));
Assert.That(result.UserBId, Is.EqualTo(userB));
Assert.That(result.Id, Is.Not.EqualTo(Guid.Empty));
Assert.That(addedChat, Is.Not.Null);
Assert.That(addedChat!.Id, Is.EqualTo(result.Id));
}
[Test]
public async Task CreateAsync_ShouldReturnExistingChat_WhenChatAlreadyExists()
{
// Arrange
var userA = Guid.NewGuid();
var userB = Guid.NewGuid();
var existingChat = _fixture.Build<PrivateChat>()
.With(x => x.UserAId, userA)
.With(x => x.UserBId, userB)
.Create();
_mockPrivateChats
.Setup(x => x.Exist(userA, userB))
.Returns(true);
_mockPrivateChats
.Setup(x => x.GetByMembersAsync(userA, userB))
.ReturnsAsync(existingChat);
// Act
var result = await _service.CreateAsync(userA, userB);
// Assert
_mockPrivateChats.Verify(x => x.AddAsync(It.IsAny<PrivateChat>()), Times.Never);
_mockPrivateChatGroupManager.Verify(
x => x.AddUsersToPrivateChatGroupAsync(It.IsAny<PrivateChat>()),
Times.Never);
_mockPrivateChats.Verify(x => x.GetByMembersAsync(userA, userB), Times.Once);
Assert.That(result, Is.EqualTo(existingChat));
}
}
@@ -1,155 +0,0 @@
using Govor.Application.Services.UserSessions;
using Govor.Domain.Models.Users;
using Govor.Domain.Repositories.UserSessionsRepository;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Moq;
using Govor.Application.Interfaces.Authentication;
using Govor.Application.Services.Authentication;
using Govor.Data.Repositories.Exceptions;
namespace Govor.Application.Tests.Services.UserSessions;
[TestFixture]
public class UserSessionOpenerTests
{
private Mock<IUserSessionsRepository> _repositoryMock;
private Mock<IJwtService> _jwtServiceMock;
private Mock<IJwtTokenHasher> _jwtTokenHasherMock;
private UserSessionOpener _service;
private User _user;
private const string DeviceInfo = "Chrome on Windows";
private const string RefreshToken = "new-refresh-token";
private const string AccessToken = "new-access-token";
private const string TokenHash = "hashed-refresh-token";
[SetUp]
public void Setup()
{
_repositoryMock = new Mock<IUserSessionsRepository>();
_jwtServiceMock = new Mock<IJwtService>();
var loggerMock = new Mock<ILogger<UserSessionOpener>>();
_jwtTokenHasherMock = new Mock<IJwtTokenHasher>();
var options = Options.Create(new JwtRefreshOption { RefreshTokenLifetimeDays = 30 });
_user = new User
{
Id = Guid.NewGuid(),
Username = "test",
Description = "some description",
PasswordHash = "hashed-password",
IconId = Guid.NewGuid(),
CreatedOn = DateOnly.FromDateTime(DateTime.Now),
WasOnline = DateTime.Now,
InviteId = Guid.NewGuid(),
// ...
};
_jwtServiceMock.Setup(j => j.GenerateRefreshTokenAsync(_user)).ReturnsAsync(RefreshToken);
_jwtTokenHasherMock.Setup(h => h.HashToken(RefreshToken)).Returns(TokenHash);
_jwtServiceMock.Setup(j => j.GenerateAccessTokenAsync(_user, It.IsAny<Guid>())).ReturnsAsync(AccessToken);
_service = new UserSessionOpener(
_repositoryMock.Object,
_jwtServiceMock.Object,
_jwtTokenHasherMock.Object,
options,
loggerMock.Object
);
}
// UpdateExistingSessionAsync
[Test]
public async Task OpenSessionAsync_ShouldUpdateExistingSession_WhenFoundByDeviceInfo()
{
// Arrange
var existingSessionId = Guid.NewGuid();
var existingSession = new UserSession
{
Id = existingSessionId,
UserId = _user.Id,
DeviceInfo = DeviceInfo,
RefreshTokenHash = "old-hash",
CreatedAt = DateTime.UtcNow.AddDays(-10),
ExpiresAt = DateTime.UtcNow.AddDays(10),
IsRevoked = true
};
_repositoryMock.Setup(r => r.GetByUserIdAsync(_user.Id)).ReturnsAsync(new List<UserSession> { existingSession });
// Act
var result = await _service.OpenSessionAsync(_user, DeviceInfo);
// Assert
Assert.Multiple(() =>
{
Assert.That(result.refreshToken, Is.EqualTo(RefreshToken), "Должен быть возвращен новый RefreshToken.");
Assert.That(result.accessToken, Is.EqualTo(AccessToken), "Должен быть возвращен новый AccessToken.");
});
_repositoryMock.Verify(r => r.UpdateAsync(It.Is<UserSession>(s =>
s.Id == existingSessionId &&
s.RefreshTokenHash == TokenHash &&
s.IsRevoked == false &&
s.ExpiresAt > DateTime.UtcNow
)), Times.Once, "Должен быть вызван метод UpdateAsync с новыми данными.");
_repositoryMock.Verify(r => r.AddAsync(It.IsAny<UserSession>()), Times.Never);
}
// CreateNewSessionAsync
[Test]
public async Task OpenSessionAsync_ShouldCreateNewSession_IfNoneFound()
{
// Arrange
_repositoryMock.Setup(r => r.GetByUserIdAsync(_user.Id)).ReturnsAsync(new List<UserSession>());
// Act
var result = await _service.OpenSessionAsync(_user, DeviceInfo);
// Assert
Assert.Multiple(() =>
{
Assert.That(result.refreshToken, Is.EqualTo(RefreshToken), "Должен быть возвращен новый RefreshToken.");
Assert.That(result.accessToken, Is.EqualTo(AccessToken), "Должен быть возвращен новый AccessToken.");
});
_repositoryMock.Verify(r => r.AddAsync(It.Is<UserSession>(s =>
s.UserId == _user.Id &&
s.DeviceInfo == DeviceInfo &&
s.RefreshTokenHash == TokenHash &&
s.IsRevoked == false
)), Times.Once, "Должен быть вызван метод AddAsync для создания новой сессии.");
_repositoryMock.Verify(r => r.UpdateAsync(It.IsAny<UserSession>()), Times.Never);
}
[Test]
public async Task OpenSessionAsync_ShouldCreateNewSession_WhenRepositoryThrowsNotFoundByKeyException()
{
// Arrange
_repositoryMock
.Setup(r => r.GetByUserIdAsync(_user.Id))
.ThrowsAsync(new NotFoundByKeyException<Guid>(_user.Id, "userId"));
// Act
var result = await _service.OpenSessionAsync(_user, DeviceInfo);
// Assert
Assert.Multiple(() =>
{
Assert.That(result.refreshToken, Is.EqualTo(RefreshToken), "Должен быть возвращен новый RefreshToken.");
Assert.That(result.accessToken, Is.EqualTo(AccessToken), "Должен быть возвращен новый AccessToken.");
});
_repositoryMock.Verify(r => r.AddAsync(It.Is<UserSession>(s =>
s.RefreshTokenHash == TokenHash
)), Times.Once, "Должен быть вызван AddAsync после перехвата исключения.");
_repositoryMock.Verify(r => r.UpdateAsync(It.IsAny<UserSession>()), Times.Never);
}
}
@@ -1,75 +0,0 @@
using AutoFixture;
using Govor.Application.Interfaces.UserSession;
using Govor.Application.Services.UserSessions;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Govor.Domain.Repositories.UserSessionsRepository;
using Govor.Data.Repositories.Exceptions;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.Application.Tests.Services.UserSessions;
[TestFixture]
[TestOf(typeof(UserSessionReader))]
public class UserSessionReaderTests
{
private Mock<IUserSessionsRepository> _mockUserSessionsRepository;
private Mock<ILogger<UserSessionReader>> _mockLogger;
private Fixture _fixture;
private IUserSessionReader _userSessionReader;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors.OfType<ThrowingRecursionBehavior>()
.ToList()
.ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_mockUserSessionsRepository = new Mock<IUserSessionsRepository>();
_mockLogger = new Mock<ILogger<UserSessionReader>>();
_userSessionReader = new UserSessionReader(_mockUserSessionsRepository.Object,
_mockLogger.Object);
}
[Test]
public async Task GetAllUserSessionsAsync_ShouldReturnAllUserSessions()
{
// Arrange
var sessios = _fixture.Build<UserSession>()
.With(f => f.IsRevoked, false)
.CreateMany().ToList();
var userId = Guid.NewGuid();
_mockUserSessionsRepository.Setup(f => f.GetByUserIdAsync(userId))
.ReturnsAsync(sessios);
// Act
var result = await _userSessionReader.GetAllSessionsAsync(userId);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EquivalentTo(sessios));
}
[Test]
public async Task GetAllUserSessionsAsync_ThrowsNotFoundByKeyException_ReturnsEmptyList()
{
// Arrange
var userId = Guid.NewGuid();
_mockUserSessionsRepository.Setup(f => f.GetByUserIdAsync(userId))
.ThrowsAsync(new NotFoundByKeyException<Guid>(userId));
// Act
var result = await _userSessionReader.GetAllSessionsAsync(userId);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.Empty);
}
}
@@ -1,148 +0,0 @@
using Govor.Application.Interfaces.Authentication;
using Govor.Application.Services.Authentication;
using Govor.Application.Services.UserSessions;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Govor.Domain.Repositories.Users;
using Govor.Domain.Repositories.UserSessionsRepository;
using Govor.Data.Repositories.Exceptions;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Moq;
namespace Govor.Application.Tests.Services.UserSessions;
[TestFixture]
public class UserSessionRefresherTests
{
private Mock<IUserSessionsRepository> _sessionsRepoMock;
private Mock<IUsersRepository> _usersRepoMock;
private Mock<IJwtService> _jwtServiceMock;
private Mock<ILogger<UserSessionRefresher>> _loggerMock;
private Mock<IOptions<JwtRefreshOption>> _optionsMock;
private Mock<IJwtTokenHasher> _jwtTokenHasherMock;
private JwtRefreshOption _options;
private UserSessionRefresher _refresher;
private const string OldRefreshToken = "old-refresh-token";
private const string NewRefreshToken = "new-refresh-token";
private const string NewAccessToken = "new-access-token";
private User _user;
private UserSession _session;
[SetUp]
public void Setup()
{
_sessionsRepoMock = new Mock<IUserSessionsRepository>();
_usersRepoMock = new Mock<IUsersRepository>();
_jwtServiceMock = new Mock<IJwtService>();
_loggerMock = new Mock<ILogger<UserSessionRefresher>>();
_optionsMock = new Mock<IOptions<JwtRefreshOption>>();
_jwtTokenHasherMock = new Mock<IJwtTokenHasher>();
_options = new JwtRefreshOption { RefreshTokenLifetimeDays = 30 };
_optionsMock.SetupGet(o => o.Value).Returns(_options);
_refresher = new UserSessionRefresher(
_sessionsRepoMock.Object,
_loggerMock.Object,
_usersRepoMock.Object,
_optionsMock.Object,
_jwtTokenHasherMock.Object,
_jwtServiceMock.Object);
_user = new User
{
Id = Guid.NewGuid(),
Username = "TestUser",
PasswordHash = "hash",
InviteId = Guid.NewGuid()
};
_session = new UserSession
{
RefreshTokenHash = OldRefreshToken,
UserId = _user.Id,
DeviceInfo = "Chrome",
CreatedAt = DateTime.UtcNow.AddDays(-5),
ExpiresAt = DateTime.UtcNow.AddDays(5),
IsRevoked = false
};
}
[Test]
public async Task RefreshTokenAsync_ValidToken_ReturnsNewTokensAndCreatesNewSession()
{
// Arrange
_sessionsRepoMock.Setup(r => r.GetByHashedRefreshTokenAsync(OldRefreshToken)).ReturnsAsync(_session);
_jwtTokenHasherMock.Setup(h => h.HashToken(It.IsAny<string>())).Returns(OldRefreshToken);
_usersRepoMock.Setup(r => r.FindByIdAsync(_user.Id)).ReturnsAsync(_user);
_jwtServiceMock.Setup(j => j.GenerateAccessTokenAsync(_user, _session.Id)).ReturnsAsync(NewAccessToken);
_jwtServiceMock.Setup(j => j.GenerateRefreshTokenAsync(_user)).ReturnsAsync(NewRefreshToken);
// Act
var result = await _refresher.RefreshTokenAsync(OldRefreshToken);
// Assert
Assert.Multiple(() =>
{
Assert.That(result.accessToken, Is.EqualTo(NewAccessToken));
Assert.That(result.refreshToken, Is.EqualTo(NewRefreshToken));
});
_sessionsRepoMock.Verify(
r => r.UpdateAsync(
It.Is<UserSession>(s =>
s.Id == _session.Id &&
s.UserId == _user.Id &&
s.IsRevoked == false
)),
Times.Once);
_sessionsRepoMock.Verify(r => r.AddAsync(It.IsAny<UserSession>()), Times.Never);
}
[Test]
public void RefreshTokenAsync_RevokedToken_ThrowsUnauthorizedAccessException()
{
// Arrange
_session.IsRevoked = true;
_sessionsRepoMock.Setup(r => r.GetByHashedRefreshTokenAsync(OldRefreshToken)).ReturnsAsync(_session);
_jwtTokenHasherMock.Setup(h => h.HashToken(It.IsAny<string>())).Returns(OldRefreshToken);
// Act & Assert
var ex = Assert.ThrowsAsync<UnauthorizedAccessException>(async () =>
await _refresher.RefreshTokenAsync(OldRefreshToken));
Assert.That(ex.Message, Contains.Substring("Refresh token is invalid or expired"));
}
[Test]
public void RefreshTokenAsync_ExpiredToken_ThrowsUnauthorizedAccessException()
{
// Arrange
_session.ExpiresAt = DateTime.UtcNow.AddMinutes(-1);
_sessionsRepoMock.Setup(r => r.GetByHashedRefreshTokenAsync(OldRefreshToken)).ReturnsAsync(_session);
_jwtTokenHasherMock.Setup(h => h.HashToken(It.IsAny<string>())).Returns(OldRefreshToken);
// Act & Assert
var ex = Assert.ThrowsAsync<UnauthorizedAccessException>(async () =>
await _refresher.RefreshTokenAsync(OldRefreshToken));
Assert.That(ex.Message, Contains.Substring("Refresh token is invalid or expired"));
}
[Test]
public void RefreshTokenAsync_TokenNotFound_ThrowsUnauthorizedAccessException()
{
// Arrange
_sessionsRepoMock.Setup(r => r.GetByHashedRefreshTokenAsync(OldRefreshToken))
.ThrowsAsync(new NotFoundByKeyException<string>("token", OldRefreshToken));
_jwtTokenHasherMock.Setup(h => h.HashToken(It.IsAny<string>())).Returns(OldRefreshToken);
// Act & Assert
var ex = Assert.ThrowsAsync<UnauthorizedAccessException>(async () =>
await _refresher.RefreshTokenAsync(OldRefreshToken));
Assert.That(ex.Message, Contains.Substring("Invalid refresh token"));
}
}
@@ -1,168 +0,0 @@
using Govor.Application.Services.UserSessions;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Govor.Domain.Repositories.PushTokens;
using Govor.Domain.Repositories.UserSessionsRepository;
using Govor.Data.Repositories.Exceptions;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.Application.Tests.Services.UserSessions;
[TestFixture]
[TestOf(typeof(UserSessionRevoker))]
public class UserSessionRevokerTests
{
private Mock<IUserSessionsRepository> _sessionsRepositoryMock;
private Mock<ILogger<UserSessionRevoker>> _loggerMock;
private Mock<IPushTokenRepository> _pushTokenRepositoryMock;
private UserSessionRevoker _revoker;
[SetUp]
public void SetUp()
{
_sessionsRepositoryMock = new Mock<IUserSessionsRepository>();
_loggerMock = new Mock<ILogger<UserSessionRevoker>>();
_pushTokenRepositoryMock = new Mock<IPushTokenRepository>();
_revoker = new UserSessionRevoker(_sessionsRepositoryMock.Object, _pushTokenRepositoryMock.Object, _loggerMock.Object);
}
[Test]
public async Task CloseSessionByIdAsync_ValidSessionAndUserId_SetsIsRevokedAndUpdates()
{
// Arrange
var sessionId = Guid.NewGuid();
var userId = Guid.NewGuid();
var session = new UserSession { Id = sessionId, UserId = userId, IsRevoked = false };
_sessionsRepositoryMock.Setup(r => r.GetByIdAsync(sessionId)).ReturnsAsync(session);
// Act
await _revoker.CloseSessionByIdAsync(sessionId, userId);
// Assert
Assert.That(session.IsRevoked, Is.True);
_sessionsRepositoryMock.Verify(r => r.UpdateAsync(session), Times.Once());
_pushTokenRepositoryMock.Verify(r => r.DeactivateTokenBySessionAsync(sessionId), Times.Once());
_loggerMock.VerifyNoOtherCalls();
}
[Test]
public void CloseSessionByIdAsync_UnauthorizedUser_ThrowsUnauthorizedAccessException()
{
// Arrange
var sessionId = Guid.NewGuid();
var userId = Guid.NewGuid();
var differentUserId = Guid.NewGuid();
var session = new UserSession { Id = sessionId, UserId = userId, IsRevoked = false };
_sessionsRepositoryMock.Setup(r => r.GetByIdAsync(sessionId)).ReturnsAsync(session);
// Act & Assert
var ex = Assert.ThrowsAsync<UnauthorizedAccessException>(() =>
_revoker.CloseSessionByIdAsync(sessionId, differentUserId));
Assert.That(ex.Message, Contains.Substring($"User {differentUserId} does not belong to this session {sessionId}"));
_loggerMock.Verify(l => l.Log(
LogLevel.Warning,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
It.IsAny<Exception>(),
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
_sessionsRepositoryMock.Verify(r => r.UpdateAsync(It.IsAny<UserSession>()), Times.Never());
_pushTokenRepositoryMock.Verify(r => r.DeactivateTokenBySessionAsync(sessionId), Times.Never());
}
[Test]
public async Task CloseSessionByIdAsync_AlreadyRevokedSession_DoesNotUpdate()
{
// Arrange
var sessionId = Guid.NewGuid();
var userId = Guid.NewGuid();
var session = new UserSession { Id = sessionId, UserId = userId, IsRevoked = true };
_sessionsRepositoryMock.Setup(r => r.GetByIdAsync(sessionId)).ReturnsAsync(session);
// Act
await _revoker.CloseSessionByIdAsync(sessionId, userId);
// Assert
_sessionsRepositoryMock.Verify(r => r.UpdateAsync(It.IsAny<UserSession>()), Times.Never());
_pushTokenRepositoryMock.Verify(r => r.DeactivateTokenBySessionAsync(sessionId), Times.Never());
_loggerMock.VerifyNoOtherCalls();
}
[Test]
public void CloseSessionByIdAsync_NonExistentSession_ThrowsNotFoundException()
{
// Arrange
var sessionId = Guid.NewGuid();
var userId = Guid.NewGuid();
_sessionsRepositoryMock.Setup(r => r.GetByIdAsync(sessionId))
.ThrowsAsync(new NotFoundByKeyException<Guid>(sessionId));
// Act & Assert
var ex = Assert.ThrowsAsync<NotFoundException>(() =>
_revoker.CloseSessionByIdAsync(sessionId, userId));
Assert.That(ex.Message, Is.EqualTo("Session not found"));
_loggerMock.Verify(l => l.Log(
LogLevel.Warning,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
It.IsAny<Exception>(),
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
_sessionsRepositoryMock.Verify(r => r.UpdateAsync(It.IsAny<UserSession>()), Times.Never());
_pushTokenRepositoryMock.Verify(r => r.DeactivateTokenBySessionAsync(sessionId), Times.Never());
}
[Test]
public async Task CloseAllSessionsAsync_MultipleSessions_RevokesNonRevokedSessions()
{
// Arrange
var userId = Guid.NewGuid();
var sessions = new List<UserSession>
{
new UserSession { Id = Guid.NewGuid(), UserId = userId, IsRevoked = false },
new UserSession { Id = Guid.NewGuid(), UserId = userId, IsRevoked = true },
new UserSession { Id = Guid.NewGuid(), UserId = userId, IsRevoked = false }
};
_sessionsRepositoryMock.Setup(r => r.GetByUserIdAsync(userId)).ReturnsAsync(sessions);
// Act
await _revoker.CloseAllSessionsAsync(userId);
// Assert
Assert.That(sessions[0].IsRevoked, Is.True);
Assert.That(sessions[1].IsRevoked, Is.True);
Assert.That(sessions[2].IsRevoked, Is.True);
_sessionsRepositoryMock.Verify(r => r.UpdateAsync(sessions[0]), Times.Once());
_sessionsRepositoryMock.Verify(r => r.UpdateAsync(sessions[2]), Times.Once());
_pushTokenRepositoryMock.Verify(r => r.DeactivateTokenBySessionAsync(sessions[0].Id), Times.Once());
_pushTokenRepositoryMock.Verify(r => r.DeactivateTokenBySessionAsync(sessions[2].Id), Times.Once());
_sessionsRepositoryMock.Verify(r => r.UpdateAsync(sessions[1]), Times.Never());
_pushTokenRepositoryMock.Verify(r => r.DeactivateTokenBySessionAsync(sessions[1].Id), Times.Never);
_loggerMock.VerifyNoOtherCalls();
}
[Test]
public void CloseAllSessionsAsync_NoSessions_ThrowsNotFoundException()
{
// Arrange
var userId = Guid.NewGuid();
_sessionsRepositoryMock.Setup(r => r.GetByUserIdAsync(userId))
.ThrowsAsync(new NotFoundByKeyException<Guid>(userId));
// Act & Assert
var ex = Assert.ThrowsAsync<NotFoundException>(() =>
_revoker.CloseAllSessionsAsync(userId));
Assert.That(ex.Message, Is.EqualTo("Session not found"));
_loggerMock.Verify(l => l.Log(
LogLevel.Warning,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
It.IsAny<Exception>(),
It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once());
_pushTokenRepositoryMock.Verify(r => r.DeactivateTokenBySessionAsync(It.IsAny<Guid>()), Times.Never);
_sessionsRepositoryMock.Verify(r => r.UpdateAsync(It.IsAny<UserSession>()), Times.Never());
}
}
@@ -1,95 +0,0 @@
using AutoFixture;
using Govor.Application.Exceptions.VerifyFriendship;
using Govor.Domain.Models;
using Govor.Domain.Repositories.Friendships;
using Govor.Data.Repositories.Exceptions;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.Application.Tests.Services;
[TestFixture]
public class VerifyFriendshipTests
{
private Fixture _fixture;
private Mock<ILogger<VerifyFriendship>> _mockLogger;
private Mock<IFriendshipsRepository> _mockFriendships;
private VerifyFriendship _service;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors
.OfType<ThrowingRecursionBehavior>()
.ToList()
.ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_mockLogger = new Mock<ILogger<VerifyFriendship>>();
_mockFriendships = new Mock<IFriendshipsRepository>();
_service = new VerifyFriendship(_mockFriendships.Object, _mockLogger.Object);
}
// Test for VerifyAsync action
[Test]
public async Task VerifyAsync_Success()
{
// Arrange
var friendship1 = _fixture.Create<Friendship>();
friendship1.Status = FriendshipStatus.Accepted;
_mockFriendships.Setup(f => f.FindByUserIdAsync(friendship1.RequesterId))
.ReturnsAsync([friendship1]);
// Act
await _service.VerifyAsync(friendship1.RequesterId, friendship1.AddresseeId);
// Assert
_mockFriendships.Verify(f => f.FindByUserIdAsync(friendship1.RequesterId), Times.Once());
Assert.That(await _service.TryVerifyAsync(friendship1.RequesterId, friendship1.AddresseeId), Is.EqualTo(true));
}
[Test]
public async Task VerifyAsync_IDsEmpty()
{
// Arrange
var friendship1 = _fixture.Create<Friendship>();
friendship1.RequesterId = Guid.Empty;
friendship1.AddresseeId = Guid.Empty;
// Act & Assert
Assert.ThrowsAsync<ArgumentException>(() => _service.VerifyAsync(friendship1.RequesterId, friendship1.AddresseeId));
Assert.That(await _service.TryVerifyAsync(friendship1.RequesterId, friendship1.AddresseeId), Is.EqualTo(false));
}
[Test]
public async Task VerifyAsync_ThrowsNotFoundByKeyException_ThrowsFriendshipException()
{
// Arrange
var friendship1 = _fixture.Create<Friendship>();
friendship1.Status = FriendshipStatus.Accepted;
_mockFriendships.Setup(f => f.FindByUserIdAsync(friendship1.RequesterId))
.ThrowsAsync(new NotFoundByKeyException<Guid>(friendship1.RequesterId));
// Act & Assert
Assert.ThrowsAsync<FriendshipException>(async () => await _service.VerifyAsync(friendship1.RequesterId, friendship1.AddresseeId));
_mockFriendships.Verify(f => f.FindByUserIdAsync(friendship1.RequesterId), Times.Once());
Assert.That(await _service.TryVerifyAsync(friendship1.RequesterId, friendship1.AddresseeId), Is.EqualTo(false));
}
[Test]
public async Task VerifyAsync_ReturnsEmptyFriendships_ThrowsFriendshipException()
{
// Arrange
var friendship1 = _fixture.Create<Friendship>();
friendship1.Status = FriendshipStatus.Accepted;
_mockFriendships.Setup(f => f.FindByUserIdAsync(friendship1.RequesterId))
.ReturnsAsync(new List<Friendship>());
// Act & Assert
Assert.ThrowsAsync<FriendshipException>(async () => await _service.VerifyAsync(friendship1.RequesterId, friendship1.AddresseeId));
_mockFriendships.Verify(f => f.FindByUserIdAsync(friendship1.RequesterId), Times.Once());
Assert.That(await _service.TryVerifyAsync(friendship1.RequesterId, friendship1.AddresseeId), Is.EqualTo(false));
}
}
+109 -32
View File
@@ -1,6 +1,7 @@
using System.Security.Cryptography; using System.Security.Cryptography;
using System.Text; using System.Text;
using System.Text.Json; using System.Text.Json;
using System.Text.Json.Nodes;
using Jose; using Jose;
using AesGcm = System.Security.Cryptography.AesGcm; using AesGcm = System.Security.Cryptography.AesGcm;
@@ -8,19 +9,39 @@ namespace Govor.Application.E2ee;
// Shared verbatim with the mobile client. JOSE implements RFC 7515/7516; // Shared verbatim with the mobile client. JOSE implements RFC 7515/7516;
// the application envelope binds the ciphertext to its author and conversation. // the application envelope binds the ciphertext to its author and conversation.
public sealed record DeviceKey(Guid UserId, Guid SessionId, string IdentityKey, public sealed record DeviceKey(
string EncryptionKey, string Signature) Guid UserId,
Guid SessionId,
string IdentityKey,
string EncryptionKey,
string Signature)
{ {
public string Fingerprint => E2eeProtocol.Fingerprint(IdentityKey, EncryptionKey); public string Fingerprint => E2eeProtocol.Fingerprint(IdentityKey, EncryptionKey);
} }
public sealed record ConversationKeys(Guid ConversationId, int RecipientType, public sealed record ConversationKeys(
Guid[] Members, DeviceKey[] Devices); Guid ConversationId,
int RecipientType,
Guid[] Members,
DeviceKey[] Devices);
public sealed record AttachmentSecret(Guid MediaId, string Key, string FileName, string MimeType); public sealed record AttachmentSecret(Guid MediaId, string Key, string FileName, string MimeType);
public sealed record MessagePlaintext(string Text, AttachmentSecret[] Attachments); public sealed record MessagePlaintext(string Text, AttachmentSecret[] Attachments);
public sealed record EncryptedMessage(int Version, Guid MessageId, Guid ConversationId,
int RecipientType, DeviceKey Sender, Guid? ReplyToMessageId, long CreatedAt, public sealed record EncryptedMessage(
bool IsEdit, string[] Recipients, Guid[] MediaIds, string Ciphertext); int Version,
Guid MessageId,
Guid ConversationId,
int RecipientType,
DeviceKey Sender,
Guid? ReplyToMessageId,
long CreatedAt,
bool IsEdit,
string[] Recipients,
Guid[] MediaIds,
string Ciphertext);
public sealed record DevicePrivateKeys(string IdentityKey, string EncryptionKey); public sealed record DevicePrivateKeys(string IdentityKey, string EncryptionKey);
public static class E2eeProtocol public static class E2eeProtocol
@@ -31,13 +52,16 @@ public static class E2eeProtocol
public const string EncryptedMimeType = "application/vnd.govor.encrypted"; public const string EncryptedMimeType = "application/vnd.govor.encrypted";
public static readonly JsonSerializerOptions Json = new() { PropertyNameCaseInsensitive = true }; public static readonly JsonSerializerOptions Json = new() { PropertyNameCaseInsensitive = true };
public static bool IsEncrypted(string? value) => value?.StartsWith(Prefix, StringComparison.Ordinal) == true; public static bool IsEncrypted(string? value)
{
return value?.StartsWith(Prefix, StringComparison.Ordinal) == true;
}
public static DevicePrivateKeys GenerateKeys() public static DevicePrivateKeys GenerateKeys()
{ {
using var signing = ECDsa.Create(ECCurve.NamedCurves.nistP256); using var signing = ECDsa.Create(ECCurve.NamedCurves.nistP256);
using var encryption = RSA.Create(3072); using var encryption = RSA.Create(3072);
return new(Convert.ToBase64String(signing.ExportPkcs8PrivateKey()), return new DevicePrivateKeys(Convert.ToBase64String(signing.ExportPkcs8PrivateKey()),
Convert.ToBase64String(encryption.ExportPkcs8PrivateKey())); Convert.ToBase64String(encryption.ExportPkcs8PrivateKey()));
} }
@@ -50,7 +74,7 @@ public static class E2eeProtocol
// Domain separation prevents using this signature as a message signature. // Domain separation prevents using this signature as a message signature.
var signature = signing.SignData(KeyBinding(publicEncryption), HashAlgorithmName.SHA256, var signature = signing.SignData(KeyBinding(publicEncryption), HashAlgorithmName.SHA256,
DSASignatureFormat.IeeeP1363FixedFieldConcatenation); DSASignatureFormat.IeeeP1363FixedFieldConcatenation);
return new(user, session, identity, publicEncryption, Convert.ToBase64String(signature)); return new DeviceKey(user, session, identity, publicEncryption, Convert.ToBase64String(signature));
} }
public static void ValidatePublicKey(DeviceKey key) public static void ValidatePublicKey(DeviceKey key)
@@ -69,8 +93,11 @@ public static class E2eeProtocol
throw new CryptographicException("Invalid E2EE key binding signature."); throw new CryptographicException("Invalid E2EE key binding signature.");
} }
public static string Fingerprint(string identity, string encryption) => public static string Fingerprint(string identity, string encryption)
Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes($"govor-device-v1\n{identity}\n{encryption}"))); {
return Convert.ToHexString(
SHA256.HashData(Encoding.UTF8.GetBytes($"govor-device-v1\n{identity}\n{encryption}")));
}
public static string Encrypt(MessagePlaintext plaintext, DevicePrivateKeys privateKeys, public static string Encrypt(MessagePlaintext plaintext, DevicePrivateKeys privateKeys,
DeviceKey sender, ConversationKeys conversation, Guid messageId, Guid? replyTo = null, DeviceKey sender, ConversationKeys conversation, Guid messageId, Guid? replyTo = null,
@@ -96,7 +123,8 @@ public static class E2eeProtocol
}).ToArray(); }).ToArray();
var ciphertext = JWE.Encrypt(JsonSerializer.Serialize(plaintext), recipients, JweEncryption.A256GCM); var ciphertext = JWE.Encrypt(JsonSerializer.Serialize(plaintext), recipients, JweEncryption.A256GCM);
var envelope = new EncryptedMessage(1, messageId, conversation.ConversationId, var envelope = new EncryptedMessage(1, messageId, conversation.ConversationId,
conversation.RecipientType, sender, replyTo, createdAt ?? DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(), conversation.RecipientType, sender, replyTo,
createdAt ?? DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
isEdit, devices.Select(k => k.Fingerprint).Order(StringComparer.Ordinal).ToArray(), isEdit, devices.Select(k => k.Fingerprint).Order(StringComparer.Ordinal).ToArray(),
plaintext.Attachments.Select(a => a.MediaId).Order().ToArray(), ciphertext); plaintext.Attachments.Select(a => a.MediaId).Order().ToArray(), ciphertext);
using var signing = SigningPrivateKey(privateKeys); using var signing = SigningPrivateKey(privateKeys);
@@ -104,7 +132,10 @@ public static class E2eeProtocol
if (result.Length > MaxEnvelopeLength) throw new CryptographicException("E2EE envelope is too large."); if (result.Length > MaxEnvelopeLength) throw new CryptographicException("E2EE envelope is too large.");
return result; return result;
} }
finally { foreach (var key in keys) key.Dispose(); } finally
{
foreach (var key in keys) key.Dispose();
}
} }
// Reading the unverified payload is used only to select its verification key. // Reading the unverified payload is used only to select its verification key.
@@ -116,7 +147,7 @@ public static class E2eeProtocol
var parts = value[Prefix.Length..].Split('.'); var parts = value[Prefix.Length..].Split('.');
if (parts.Length != 3) throw new CryptographicException("Invalid signed E2EE envelope."); if (parts.Length != 3) throw new CryptographicException("Invalid signed E2EE envelope.");
var envelope = JsonSerializer.Deserialize<EncryptedMessage>(Base64Url.Decode(parts[1]), Json) var envelope = JsonSerializer.Deserialize<EncryptedMessage>(Base64Url.Decode(parts[1]), Json)
?? throw new CryptographicException("Invalid E2EE envelope."); ?? throw new CryptographicException("Invalid E2EE envelope.");
if (envelope.Version != 1 || envelope.Sender is null || envelope.MessageId == Guid.Empty || if (envelope.Version != 1 || envelope.Sender is null || envelope.MessageId == Guid.Empty ||
envelope.ConversationId == Guid.Empty || envelope.RecipientType is < 0 or > 1 || envelope.ConversationId == Guid.Empty || envelope.RecipientType is < 0 or > 1 ||
envelope.Recipients is null || envelope.Recipients.Length is 0 or > MaxDevices || envelope.Recipients is null || envelope.Recipients.Length is 0 or > MaxDevices ||
@@ -142,7 +173,8 @@ public static class E2eeProtocol
header.RootElement.TryGetProperty("zip", out _)) header.RootElement.TryGetProperty("zip", out _))
throw new CryptographicException("Unsupported content encryption."); throw new CryptographicException("Unsupported content encryption.");
var recipients = root.TryGetProperty("recipients", out var many) var recipients = root.TryGetProperty("recipients", out var many)
? many.EnumerateArray().ToArray() : new[] { root }; ? many.EnumerateArray().ToArray()
: new[] { root };
if (recipients.Length != envelope.Recipients.Length || if (recipients.Length != envelope.Recipients.Length ||
recipients.Any(r => r.GetProperty("header").GetProperty("alg").GetString() != "RSA-OAEP-256") || recipients.Any(r => r.GetProperty("header").GetProperty("alg").GetString() != "RSA-OAEP-256") ||
!recipients.Select(r => r.GetProperty("header").GetProperty("kid").GetString()) !recipients.Select(r => r.GetProperty("header").GetProperty("kid").GetString())
@@ -170,16 +202,17 @@ public static class E2eeProtocol
throw new CryptographicException("This device cannot decrypt this message."); throw new CryptographicException("This device cannot decrypt this message.");
// Select our recipient explicitly. In particular Windows CNG can throw an // Select our recipient explicitly. In particular Windows CNG can throw an
// OS-specific error while trying another recipient's RSA-OAEP encrypted key. // OS-specific error while trying another recipient's RSA-OAEP encrypted key.
var selected = System.Text.Json.Nodes.JsonNode.Parse(envelope.Ciphertext)!; var selected = JsonNode.Parse(envelope.Ciphertext)!;
if (selected["recipients"] is System.Text.Json.Nodes.JsonArray recipients) if (selected["recipients"] is JsonArray recipients)
{ {
var recipient = recipients.Single(r => r!["header"]!["kid"]!.GetValue<string>() == fingerprint)!; var recipient = recipients.Single(r => r!["header"]!["kid"]!.GetValue<string>() == fingerprint)!;
selected["recipients"] = new System.Text.Json.Nodes.JsonArray(recipient.DeepClone()); selected["recipients"] = new JsonArray(recipient.DeepClone());
} }
var decrypted = JWE.Decrypt(selected.ToJsonString(), rsa, var decrypted = JWE.Decrypt(selected.ToJsonString(), rsa,
JweAlgorithm.RSA_OAEP_256, JweEncryption.A256GCM); JweAlgorithm.RSA_OAEP_256, JweEncryption.A256GCM);
var plaintext = JsonSerializer.Deserialize<MessagePlaintext>(decrypted.Plaintext, Json) var plaintext = JsonSerializer.Deserialize<MessagePlaintext>(decrypted.Plaintext, Json)
?? throw new CryptographicException("Invalid encrypted content."); ?? throw new CryptographicException("Invalid encrypted content.");
if (plaintext.Text is null || plaintext.Text.Length > 20_000 || plaintext.Attachments is null || if (plaintext.Text is null || plaintext.Text.Length > 20_000 || plaintext.Attachments is null ||
!plaintext.Attachments.Select(a => a.MediaId).Order().SequenceEqual(envelope.MediaIds.Order())) !plaintext.Attachments.Select(a => a.MediaId).Order().SequenceEqual(envelope.MediaIds.Order()))
throw new CryptographicException("Invalid encrypted attachment manifest."); throw new CryptographicException("Invalid encrypted attachment manifest.");
@@ -195,11 +228,15 @@ public static class E2eeProtocol
var data = new byte[12 + plaintext.Length + 16]; var data = new byte[12 + plaintext.Length + 16];
RandomNumberGenerator.Fill(data.AsSpan(0, 12)); RandomNumberGenerator.Fill(data.AsSpan(0, 12));
using var aes = new AesGcm(key, 16); using var aes = new AesGcm(key, 16);
aes.Encrypt(data.AsSpan(0, 12), plaintext, data.AsSpan(12, plaintext.Length), data.AsSpan(12 + plaintext.Length, 16), aes.Encrypt(data.AsSpan(0, 12), plaintext, data.AsSpan(12, plaintext.Length),
data.AsSpan(12 + plaintext.Length, 16),
"govor-attachment-v1"u8); "govor-attachment-v1"u8);
return (data, Convert.ToBase64String(key)); return (data, Convert.ToBase64String(key));
} }
finally { CryptographicOperations.ZeroMemory(key); } finally
{
CryptographicOperations.ZeroMemory(key);
}
} }
public static byte[] DecryptAttachment(byte[] ciphertext, string encodedKey) public static byte[] DecryptAttachment(byte[] ciphertext, string encodedKey)
@@ -215,26 +252,57 @@ public static class E2eeProtocol
ciphertext.AsSpan(12 + plaintext.Length, 16), plaintext, "govor-attachment-v1"u8); ciphertext.AsSpan(12 + plaintext.Length, 16), plaintext, "govor-attachment-v1"u8);
return plaintext; return plaintext;
} }
finally { CryptographicOperations.ZeroMemory(key); } finally
{
CryptographicOperations.ZeroMemory(key);
}
}
private static byte[] KeyBinding(string encryption)
{
return Encoding.UTF8.GetBytes("govor-key-binding-v1\n" + encryption);
} }
private static byte[] KeyBinding(string encryption) => Encoding.UTF8.GetBytes("govor-key-binding-v1\n" + encryption);
private static ECDsa SigningPrivateKey(DevicePrivateKeys keys) private static ECDsa SigningPrivateKey(DevicePrivateKeys keys)
{ {
var bytes = Convert.FromBase64String(keys.IdentityKey); var bytes = Convert.FromBase64String(keys.IdentityKey);
var key = ECDsa.Create(); var key = ECDsa.Create();
try { key.ImportPkcs8PrivateKey(bytes, out _); return key; } try
catch { key.Dispose(); throw; } {
finally { CryptographicOperations.ZeroMemory(bytes); } key.ImportPkcs8PrivateKey(bytes, out _);
return key;
}
catch
{
key.Dispose();
throw;
}
finally
{
CryptographicOperations.ZeroMemory(bytes);
}
} }
private static RSA EncryptionPrivateKey(DevicePrivateKeys keys) private static RSA EncryptionPrivateKey(DevicePrivateKeys keys)
{ {
var bytes = Convert.FromBase64String(keys.EncryptionKey); var bytes = Convert.FromBase64String(keys.EncryptionKey);
var key = RSA.Create(); var key = RSA.Create();
try { key.ImportPkcs8PrivateKey(bytes, out _); return key; } try
catch { key.Dispose(); throw; } {
finally { CryptographicOperations.ZeroMemory(bytes); } key.ImportPkcs8PrivateKey(bytes, out _);
return key;
}
catch
{
key.Dispose();
throw;
}
finally
{
CryptographicOperations.ZeroMemory(bytes);
}
} }
private static ECDsa SigningPublicKey(DeviceKey device) private static ECDsa SigningPublicKey(DeviceKey device)
{ {
var key = ECDsa.Create(); var key = ECDsa.Create();
@@ -245,8 +313,13 @@ public static class E2eeProtocol
if (read != bytes.Length) throw new CryptographicException("Trailing public key data."); if (read != bytes.Length) throw new CryptographicException("Trailing public key data.");
return key; return key;
} }
catch { key.Dispose(); throw; } catch
{
key.Dispose();
throw;
}
} }
private static RSA EncryptionPublicKey(DeviceKey device) private static RSA EncryptionPublicKey(DeviceKey device)
{ {
var key = RSA.Create(); var key = RSA.Create();
@@ -257,6 +330,10 @@ public static class E2eeProtocol
if (read != bytes.Length) throw new CryptographicException("Trailing public key data."); if (read != bytes.Length) throw new CryptographicException("Trailing public key data.");
return key; return key;
} }
catch { key.Dispose(); throw; } catch
{
key.Dispose();
throw;
}
} }
} }
@@ -1,14 +1,50 @@
using Govor.Domain;
using Govor.Domain.Models;
using Microsoft.EntityFrameworkCore;
namespace Govor.Application.Friends; namespace Govor.Application.Friends;
public class FriendsBlockService : IFriendsBlockService public class FriendsBlockService(GovorDbContext context) : IFriendsBlockService
{ {
public Task BlockFriendRequestAsync(Guid userId, Guid currentUserId) public async Task BlockFriendRequestAsync(Guid userId, Guid currentUserId)
{ {
throw new NotImplementedException(); if (userId == Guid.Empty || currentUserId == Guid.Empty || userId == currentUserId)
throw new ArgumentException("Two distinct users are required.");
if (await context.Users.CountAsync(u => u.Id == userId || u.Id == currentUserId) != 2)
throw new KeyNotFoundException("User not found.");
var friendship = await FindAsync(userId, currentUserId);
if (friendship?.Status == FriendshipStatus.Blocked)
{
if (friendship.RequesterId != currentUserId)
throw new UnauthorizedAccessException("Only the user who blocked this conversation can change the block.");
return;
}
if (friendship is null)
{
friendship = new Friendship { Id = Guid.NewGuid() };
context.Friendships.Add(friendship);
}
// A blocked row records its owner as Requester; requests cannot overwrite it.
friendship.RequesterId = currentUserId;
friendship.AddresseeId = userId;
friendship.Status = FriendshipStatus.Blocked;
await context.SaveChangesAsync();
} }
public Task UnblockFriendRequestAsync(Guid userId, Guid currentUserId) public async Task UnblockFriendRequestAsync(Guid userId, Guid currentUserId)
{ {
throw new NotImplementedException(); if (userId == Guid.Empty || currentUserId == Guid.Empty || userId == currentUserId)
throw new ArgumentException("Two distinct users are required.");
var friendship = await FindAsync(userId, currentUserId);
if (friendship?.Status != FriendshipStatus.Blocked) return;
if (friendship.RequesterId != currentUserId)
throw new UnauthorizedAccessException("Only the user who blocked this conversation can remove the block.");
// Unblocking permits a new request; it does not restore friendship without consent.
friendship.Status = FriendshipStatus.Rejected;
await context.SaveChangesAsync();
} }
private Task<Friendship?> FindAsync(Guid userId, Guid currentUserId) => context.Friendships.FirstOrDefaultAsync(f =>
(f.RequesterId == userId && f.AddresseeId == currentUserId) ||
(f.RequesterId == currentUserId && f.AddresseeId == userId));
} }
@@ -42,7 +42,7 @@ public class UsernameValidator : IUsernameValidator
public Result<Unit, Error> Validate(string username) public Result<Unit, Error> Validate(string username)
{ {
if (username.Length < UserConstants.MIN_LENGHT_OF_NAME || username.Length > UserConstants.MAX_LENGHT_OF_NAME) if (string.IsNullOrEmpty(username) || username.Length < UserConstants.MIN_LENGHT_OF_NAME || username.Length > UserConstants.MAX_LENGHT_OF_NAME)
{ {
return Result.Failure(Error.Validation( return Result.Failure(Error.Validation(
ErrorCode, ErrorCode,
+16 -11
View File
@@ -78,24 +78,29 @@ public class MediaService : IMediaService
return new Unit(); return new Unit();
} }
public Task<Result<Media, Error>> GetMediaByUrlAsync(string url) public async Task<Result<Media, Error>> GetMediaByUrlAsync(string url)
{ {
throw new NotImplementedException(); if (string.IsNullOrWhiteSpace(url))
return Result.Failure<Media>(Error.Validation("File.GetMediaByUrl", "Media URL is required."));
var file = await _dbContext.MediaFiles.AsNoTracking().FirstOrDefaultAsync(m => m.Url == url);
return await ReadMediaAsync(file, "File.GetMediaByUrl");
} }
public async Task<Result<Media, Error>> GetMediaByIdAsync(Guid mediaId) public async Task<Result<Media, Error>> GetMediaByIdAsync(Guid mediaId)
{
var file = await _dbContext.MediaFiles.AsNoTracking().FirstOrDefaultAsync(m => m.Id == mediaId);
return await ReadMediaAsync(file, "File.GetMediaById");
}
private async Task<Result<Media, Error>> ReadMediaAsync(MediaFile? mediaFile, string errorCode)
{ {
try try
{ {
var mediaFile = await _dbContext.MediaFiles
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == mediaId);
if (mediaFile is null) if (mediaFile is null)
{ {
return Result<Media, Error>.Failure(Error.NotFound( return Result<Media, Error>.Failure(Error.NotFound(
"File.GetMediaById", errorCode,
$"File with given id ({mediaId}) doesn't exist!") "Media file does not exist.")
); );
} }
@@ -114,7 +119,7 @@ public class MediaService : IMediaService
return new Media( return new Media(
mediaFile.UploaderId, mediaFile.UploaderId,
mediaFile.DateCreated, mediaFile.DateCreated,
mediaFile.MediaType.ToString(), Path.GetFileName(mediaFile.Url),
contentBytes, contentBytes,
mediaFile.MediaType, mediaFile.MediaType,
mediaFile.MineType, mediaFile.MineType,
@@ -125,8 +130,8 @@ public class MediaService : IMediaService
} }
catch (FileNotFoundException ex) catch (FileNotFoundException ex)
{ {
_logger.LogWarning(ex, "Media file ({0}) not found on storage.", mediaId); _logger.LogWarning(ex, "Media file {MediaId} not found on storage.", mediaFile?.Id);
return Result<Media, Error>.Failure(Error.ServerError("File.GetMediaById", $"Media file not found on storage!")); return Result<Media, Error>.Failure(Error.ServerError(errorCode, "Media file not found on storage!"));
} }
} }
@@ -6,7 +6,7 @@ public class LocalStorageService : IStorageService
public LocalStorageService(string contentRootPath) public LocalStorageService(string contentRootPath)
{ {
_storagePath = Path.Combine(contentRootPath, "uploads"); _storagePath = Path.GetFullPath(Path.Combine(contentRootPath, "uploads"));
if (!Directory.Exists(_storagePath)) if (!Directory.Exists(_storagePath))
{ {
@@ -38,7 +38,7 @@ public class LocalStorageService : IStorageService
public async Task<Stream> LoadAsync(string url) public async Task<Stream> LoadAsync(string url)
{ {
var filePath = Path.Combine(_storagePath, url); var filePath = ResolvePath(url);
if (!File.Exists(filePath)) if (!File.Exists(filePath))
throw new FileNotFoundException("File not found.", filePath); throw new FileNotFoundException("File not found.", filePath);
@@ -48,15 +48,7 @@ public class LocalStorageService : IStorageService
public async Task RemoveAsync(string url) public async Task RemoveAsync(string url)
{ {
if (string.IsNullOrWhiteSpace(url)) var fullPath = ResolvePath(url);
throw new ArgumentException("Invalid file url");
var rootPath = Path.GetFullPath(_storagePath);
var fullPath = Path.GetFullPath(Path.Combine(rootPath, url));
if (!fullPath.StartsWith(rootPath, StringComparison.OrdinalIgnoreCase))
throw new UnauthorizedAccessException("Invalid file path");
if (!File.Exists(fullPath)) if (!File.Exists(fullPath))
return; return;
@@ -80,4 +72,15 @@ public class LocalStorageService : IStorageService
await Task.CompletedTask; await Task.CompletedTask;
} }
private string ResolvePath(string url)
{
if (string.IsNullOrWhiteSpace(url)) throw new ArgumentException("Invalid file url", nameof(url));
if (Path.IsPathRooted(url)) throw new UnauthorizedAccessException("Invalid file path");
var fullPath = Path.GetFullPath(Path.Combine(_storagePath, url));
var comparison = OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
if (!fullPath.StartsWith(_storagePath + Path.DirectorySeparatorChar, comparison))
throw new UnauthorizedAccessException("Invalid file path");
return fullPath;
}
} }
@@ -1,9 +1,13 @@
using Govor.Domain;
using Microsoft.EntityFrameworkCore;
namespace Govor.Application.Users.UserOnlineStatus; namespace Govor.Application.Users.UserOnlineStatus;
public class UserPresenceReader : IUserPresenceReader public class UserPresenceReader(GovorDbContext context) : IUserPresenceReader
{ {
public Task<DateTime?> GetLastSeenAsync(Guid userId) public Task<DateTime?> GetLastSeenAsync(Guid userId)
{ {
throw new NotImplementedException(); return context.Users.AsNoTracking().Where(u => u.Id == userId)
.Select(u => (DateTime?)u.WasOnline).FirstOrDefaultAsync();
} }
} }
@@ -23,10 +23,13 @@ public class OneTimePreKeysRotator : IOneTimePreKeysRotator
{ {
var cryptoSession = await _context.UserCryptoSessions var cryptoSession = await _context.UserCryptoSessions
.Include(c => c.OneTimePreKeys) .Include(c => c.OneTimePreKeys)
.Include(c => c.UserSession)
.FirstOrDefaultAsync(c => c.UserSessionId == sessionId); .FirstOrDefaultAsync(c => c.UserSessionId == sessionId);
if (cryptoSession == null) if (cryptoSession == null)
throw new ArgumentException("Crypto session not found", nameof(sessionId)); throw new ArgumentException("Crypto session not found", nameof(sessionId));
if (cryptoSession.UserSession.UserId != _current.GetCurrentUserId())
throw new UnauthorizedAccessException("Only the session owner can rotate its keys.");
// Удаляем все использованные ключи // Удаляем все использованные ключи
var usedKeys = cryptoSession.OneTimePreKeys.Where(k => k.IsUsed).ToList(); var usedKeys = cryptoSession.OneTimePreKeys.Where(k => k.IsUsed).ToList();
@@ -38,9 +41,10 @@ public class OneTimePreKeysRotator : IOneTimePreKeysRotator
// Добавляем новые ключи (возможно, стоит ограничить количество) // Добавляем новые ключи (возможно, стоит ограничить количество)
foreach (var key in newOneTimePreKeys) foreach (var key in newOneTimePreKeys)
{ {
cryptoSession.OneTimePreKeys.Add(new OneTimePreKey _context.OneTimePreKeys.Add(new OneTimePreKey
{ {
Id = Guid.NewGuid(), Id = Guid.NewGuid(),
UserCryptoSessionId = cryptoSession.Id,
PublicKey = key, PublicKey = key,
IsUsed = false, IsUsed = false,
UploadedAt = DateTime.UtcNow UploadedAt = DateTime.UtcNow
@@ -54,10 +58,13 @@ public class OneTimePreKeysRotator : IOneTimePreKeysRotator
{ {
var key = await _context.OneTimePreKeys var key = await _context.OneTimePreKeys
.Include(k => k.UserCryptoSession) .Include(k => k.UserCryptoSession)
.ThenInclude(c => c.UserSession)
.FirstOrDefaultAsync(k => k.Id == oneTimePreKeyId && k.UserCryptoSession.UserSessionId == sessionId); .FirstOrDefaultAsync(k => k.Id == oneTimePreKeyId && k.UserCryptoSession.UserSessionId == sessionId);
if (key == null) if (key == null)
throw new ArgumentException("One-Time PreKey not found for this session", nameof(oneTimePreKeyId)); throw new ArgumentException("One-Time PreKey not found for this session", nameof(oneTimePreKeyId));
if (key.UserCryptoSession.UserSession.UserId != _current.GetCurrentUserId())
throw new UnauthorizedAccessException("Only the session owner can consume its keys.");
if (key.IsUsed) if (key.IsUsed)
return; // Уже помечен return; // Уже помечен
@@ -64,6 +64,7 @@ public class SessionKeyAttacher : ISessionKeyAttacher
}; };
session.CryptoSession = cryptoSession; session.CryptoSession = cryptoSession;
_context.UserCryptoSessions.Add(cryptoSession);
await _context.SaveChangesAsync(); await _context.SaveChangesAsync();
@@ -55,6 +55,7 @@ public class SessionKeysReader : ISessionKeysReader
.AsNoTracking() .AsNoTracking()
.Include(c => c.OneTimePreKeys) .Include(c => c.OneTimePreKeys)
.Include(c => c.UserSession) .Include(c => c.UserSession)
.Include(c => c.SignedPreKey)
.FirstOrDefaultAsync(c => c.UserSessionId == sessionId); .FirstOrDefaultAsync(c => c.UserSessionId == sessionId);
} }
} }
@@ -61,23 +61,6 @@ public class UserSessionOpener : IUserSessionOpener
} }
} }
private async Task<RefreshResult> UpdateExistingSessionAsync(User user, string deviceInfo, UserSession session)
{
var (accessToken, refreshToken) = await GenerateTokensAsync(user, session.Id);
var newTokenHash = _jwtTokenHasher.HashToken(refreshToken);
var newExpiresAt = DateTime.UtcNow.AddDays(_options.RefreshTokenLifetimeDays);
session.RefreshTokenHash = newTokenHash;
session.ExpiresAt = newExpiresAt;
session.CreatedAt = DateTime.UtcNow;
session.IsRevoked = false;
_logger.LogInformation("Updated session for user {UserId} on device '{DeviceInfo}'", user.Id, deviceInfo);
return new RefreshResult(refreshToken, accessToken);
}
private async Task<RefreshResult> CreateNewSessionAsync(User user, string deviceInfo) private async Task<RefreshResult> CreateNewSessionAsync(User user, string deviceInfo)
{ {
var sessionId = Guid.NewGuid(); var sessionId = Guid.NewGuid();
@@ -13,8 +13,7 @@ public class MediaUploadRequest
public MediaType Type { get; set; } public MediaType Type { get; set; }
[Required, MaxLength(255)] [Required, MaxLength(255)]
public string MimeType { get; set; } = string.Empty; public string MimeType { get; set; } = string.Empty;
[Required] public string? EncryptedKey { get; set; } = string.Empty;
public string EncryptedKey { get; set; } = string.Empty;
[Required] [Required]
public MediaOwnerType OwnerType { get; set; } = MediaOwnerType.Message; public MediaOwnerType OwnerType { get; set; } = MediaOwnerType.Message;
} }
-26
View File
@@ -1,26 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<LangVersion>latest</LangVersion>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="AutoFixture" Version="5.0.0-preview0012" />
<PackageReference Include="coverlet.collector" Version="6.0.2"/>
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.6" />
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.0.6" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0"/>
<PackageReference Include="NUnit" Version="4.2.2"/>
<PackageReference Include="NUnit.Analyzers" Version="4.4.0"/>
<PackageReference Include="NUnit3TestAdapter" Version="4.6.0"/>
</ItemGroup>
<ItemGroup>
<Using Include="NUnit.Framework"/>
</ItemGroup>
</Project>
@@ -1,176 +0,0 @@
using AutoFixture;
using Govor.Domain.Infrastructure.Validators;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Govor.Domain;
using Govor.Domain.Repositories;
using Govor.Domain.Repositories.Exceptions;
using Microsoft.EntityFrameworkCore;
namespace Govor.Domain.Tests.Repositories;
[TestFixture]
public class AdminsRepositoryTests
{
private Fixture _fixture;
private DbContextOptions<GovorDbContext> _options;
private IObjectValidator<Admin> _validator = new AdminValidator();
private int _testIteration = 0;
[SetUp]
public void Setup()
{
_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(AdminsRepositoryTests)}_{_testIteration}")
.Options;
_testIteration += 1;
}
[Test]
public async Task Given_NotEmptyDbSet_When_GetAllAsync_Then_Admins_Are_Returned()
{
// Arrange
var random = new Random();
var admins = _fixture.CreateMany<Admin>(random.Next(3, 10)).ToList();
await using var context = new GovorDbContext(_options);
var repository = new AdminsRepository(context, _validator);
context.AddRange(admins);
await context.SaveChangesAsync();
// Act
var result = await repository.GetAllAsync();
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count(), Is.EqualTo(admins.Count()));
Assert.That(result.Select(r => r.UserId), Is.EquivalentTo(admins.Select(r => r.UserId)));
}
[Test]
public async Task Given_EmptyDbSet_When_GetAllAsync_Should_Throw_NotFoundException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new AdminsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundException>(async () => await repository.GetAllAsync());
}
[Test]
public async Task Given_ValidUserId_When_GetByIdAsync_Then_Admin_Should_Return_Admin()
{
// Arrange
var admin = _fixture.Create<Admin>();
await using var context = new GovorDbContext(_options);
var repository = new AdminsRepository(context, _validator);
context.Add(admin);
await context.SaveChangesAsync();
// Act
var result = await repository.GetByIdAsync(admin.UserId);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.UserId, Is.EqualTo(admin.UserId));
}
[Test]
public async Task Given_InvalidUserId_When_GetByIdAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new AdminsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await repository.GetByIdAsync(_fixture.Create<Guid>()));
}
[Test]
public async Task Given_ValidAdmin_When_AddAsync_Then_Added()
{
// Arrange
var admin = _fixture.Create<Admin>();
await using var context = new GovorDbContext(_options);
var repository = new AdminsRepository(context, _validator);
// Act
await repository.AddAsync(admin);
// Assert
Assert.That(context.Admins.Count, Is.EqualTo(1));
Assert.That(context.Admins.First(), Is.EqualTo(admin));
}
[Test]
public async Task Given_InvalidAdmin_When_AddAsync_Should_Throw_AdditionException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new AdminsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<AdditionException>(async () => await repository.AddAsync(default));
}
[Test]
public void Given_ValidAdmin_When_Exist_Then_Returns_True()
{
// Arrange
var admin = _fixture.Create<Admin>();
using var context = new GovorDbContext(_options);
var repository = new AdminsRepository(context, _validator);
context.Add(admin);
context.SaveChanges();
// Act
var result = repository.Exist(admin.UserId);
var result2 = repository.Exist(admin);
// Assert
Assert.That(result, Is.True);
Assert.That(result2, Is.True);
}
[Test]
public void Given_ExistAdmin_When_Exist_Then_Returns_False()
{
// Arrange
var admin = _fixture.Create<Admin>();
using var context = new GovorDbContext(_options);
var repository = new AdminsRepository(context, _validator);
// Act
var result = repository.Exist(admin.UserId);
var result2 = repository.Exist(admin);
// Assert
Assert.That(result, Is.False);
Assert.That(result2, Is.False);
}
[Test]
public void Given_NullAdmin_When_Exist_Should_Throw_InvalidObjectException()
{
// Arrange
using var context = new GovorDbContext(_options);
var repository = new AdminsRepository(context, _validator);
// Act & Assert
Assert.Throws<InvalidObjectException<Admin>>(() => repository.Exist(default(Admin)));
}
}
@@ -1,191 +0,0 @@
using AutoFixture;
using Govor.Domain.Infrastructure.Validators;
using Govor.Domain.Models;
using Govor.Domain;
using Govor.Domain.Repositories;
using Govor.Domain.Repositories.Exceptions;
using Microsoft.EntityFrameworkCore;
namespace Govor.Domain.Tests.Repositories;
[TestFixture]
public class FriendshipsRepositoryTests
{
private Fixture _fixture;
private DbContextOptions<GovorDbContext> _options;
private IObjectValidator<Friendship> _validator = new FriendshipValidator();
private int _testIteration = 0;
[SetUp]
public void Setup()
{
_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(FriendshipsRepositoryTests)}_{_testIteration}")
.Options;
_testIteration += 1;
}
[Test]
public async Task Given_NotEmptyDbSet_When_GetAllAsync_Then_Friendships_Are_Returned()
{
// Arrange
var random = new Random();
var friendships = _fixture.CreateMany<Friendship>(random.Next(3, 10)).ToList();
await using var context = new GovorDbContext(_options);
var repository = new FriendshipsRepository(context, _validator);
context.AddRange(friendships);
await context.SaveChangesAsync();
// Act
var result = await repository.GetAllAsync();
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count(), Is.EqualTo(friendships.Count()));
Assert.That(result.Select(r => r.Id), Is.EquivalentTo(friendships.Select(r => r.Id)));
}
[Test]
public async Task Given_EmptyDbSet_When_GetAllAsync_Should_Throw_NotFoundException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new FriendshipsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundException>(async () => await repository.GetAllAsync());
}
[Test]
public async Task Given_ValidFriendshipId_When_GetByIdAsync_Then_Friendships_Are_Returned()
{
// Arrange
var random = new Random();
var friendships = _fixture.CreateMany<Friendship>(random.Next(3, 10)).ToList();
await using var context = new GovorDbContext(_options);
var repository = new FriendshipsRepository(context, _validator);
context.AddRange(friendships);
await context.SaveChangesAsync();
// Act
var result = await repository.GetByIdAsync(friendships.First().Id);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Id, Is.EqualTo(friendships.First().Id));
}
[Test]
public async Task Given_InvalidFriendshipId_When_GetByIdAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new FriendshipsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await repository.GetByIdAsync(_fixture.Create<Guid>()));
}
[Test]
public async Task Given_ValidUserId_When_GetByIdAsync_Then_Friendships_Are_Returned()
{
// Arrange
var random = new Random();
var friendships = _fixture.CreateMany<Friendship>(random.Next(3, 10)).ToList();
await using var context = new GovorDbContext(_options);
var repository = new FriendshipsRepository(context, _validator);
context.AddRange(friendships);
await context.SaveChangesAsync();
// Act
var result = await repository.FindByUserIdAsync(friendships.First().RequesterId);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.First().Id, Is.EqualTo(friendships.First().Id));
}
[Test]
public async Task Given_InvalidUserId_When_GetByIdAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new FriendshipsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await repository.FindByUserIdAsync(_fixture.Create<Guid>()));
}
[Test]
public async Task Given_ValidFriendship_When_AddAsync_Then_Added()
{
// Arrange
var friendship = _fixture.Create<Friendship>();
await using var context = new GovorDbContext(_options);
var repository = new FriendshipsRepository(context, _validator);
// Act
await repository.AddAsync(friendship);
// Assert
Assert.That(context.Friendships.Count, Is.EqualTo(1));
Assert.That(context.Friendships.First().Id, Is.EqualTo(friendship.Id));
}
[Test]
public async Task Given_InvalidFriendship_When_AddAsync_Should_Throw_AdditionException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new FriendshipsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<AdditionException>(async () => await repository.AddAsync(default));
}
[Test]
public async Task Given_ExistFriendship_When_Exist_Then_True()
{
// Arrange
var friendship = _fixture.Create<Friendship>();
await using var context = new GovorDbContext(_options);
var repository = new FriendshipsRepository(context, _validator);
context.Friendships.Add(friendship);
await context.SaveChangesAsync();
// Act
var result = repository.Exist(friendship.RequesterId, friendship.AddresseeId);
// Assert
Assert.That(result, Is.True);
}
[Test]
public async Task Given_NotExistFriendship_When_Exist_Then_False()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new FriendshipsRepository(context, _validator);
// Act & Assert
Assert.That(repository.Exist(_fixture.Create<Guid>(), _fixture.Create<Guid>()), Is.False);
}
}
@@ -1,308 +0,0 @@
using AutoFixture;
using Govor.Domain.Infrastructure.Validators;
using Govor.Domain.Models;
using Govor.Domain;
using Govor.Domain.Repositories;
using Govor.Domain.Repositories.Exceptions;
using Microsoft.EntityFrameworkCore;
namespace Govor.Domain.Tests.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);
}
}
@@ -1,249 +0,0 @@
using AutoFixture;
using Govor.Domain.Infrastructure.Validators;
using Govor.Domain.Models;
using Govor.Domain;
using Govor.Domain.Repositories;
using Govor.Domain.Repositories.Exceptions;
using Microsoft.EntityFrameworkCore;
namespace Govor.Domain.Tests.Repositories;
[TestFixture]
public class InvitesRepositoryTests
{
private Fixture _fixture;
private DbContextOptions<GovorDbContext> _options;
private IObjectValidator<Invitation> _validator = new InvitationValidator();
private int _testIteration = 0;
[SetUp]
public void Setup()
{
_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(InvitesRepositoryTests)}_{_testIteration}")
.Options;
_testIteration += 1;
}
[Test]
public async Task Given_NotEmptyDbSet_When_GetAllAsync_Then_Invites_Are_Returned()
{
// Arrange
var random = new Random();
var invitations = _fixture.CreateMany<Invitation>(random.Next(3, 10)).ToList();
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
context.Invitations.AddRange(invitations);
await context.SaveChangesAsync();
// Act
var result = await repository.GetAllAsync();
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count(), Is.EqualTo(invitations.Count()));
Assert.That(result, Is.EquivalentTo(invitations));
}
[Test]
public async Task Given_EmptyDbSet_When_GetAllAsync_Should_Throw_NotFoundException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundException>(async () => await repository.GetAllAsync());
}
[Test]
public async Task Given_ValidInvitesId_When_FindByIdAsync_Then_Invites_Are_Returned()
{
// Arrange
var invitation = _fixture.Create<Invitation>();
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
context.Invitations.Add(invitation);
await context.SaveChangesAsync();
// Act
var result = await repository.FindByIdAsync(invitation.Id);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Id, Is.EqualTo(invitation.Id));
}
[Test]
public async Task Given_InvalidInvitesId_When_FindByIdAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await repository.FindByIdAsync(Guid.Empty));
}
[Test]
public async Task Given_ValidInvitesCode_When_FindByCodeAsync_Then_Invites_Are_Returned()
{
// Arrange
var invitation = _fixture.Create<Invitation>();
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
context.Invitations.Add(invitation);
await context.SaveChangesAsync();
// Act
var result = await repository.FindByCodeAsync(invitation.Code);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Id, Is.EqualTo(invitation.Id));
}
[Test]
public async Task Given_InvalidCode_When_FindByCodeAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<string>>(async () => await repository.FindByCodeAsync(_fixture.Create<string>()));
}
[Test]
public async Task Given_ValidAdminInvites_When_FindAdminsInvitesAsync_Then_Invites_Are_Returned()
{
// Arrange
var random = new Random();
var invitations = _fixture.CreateMany<Invitation>(random.Next(3, 10)).ToList();
foreach (var inv in invitations)
{
inv.IsAdmin = true;
}
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
context.Invitations.AddRange(invitations);
await context.SaveChangesAsync();
// Act
var result = await repository.FindAdminsInvitesAsync();
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count(), Is.EqualTo(invitations.Count()));
Assert.That(result, Is.EquivalentTo(invitations));
}
[Test]
public async Task Given_InvalidAdminsInvites_When_FindAdminsInvitesAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<bool>>(async () => await repository.FindAdminsInvitesAsync());
}
[Test]
public async Task Given_ValidAdmin_When_AddAsync_Then_Added()
{
// Arrange
var invitation = _fixture.Create<Invitation>();
invitation.Code = string.Join("", _fixture.CreateMany<char>(12));
invitation.EndDate = invitation.DateCreated.AddHours(1);
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
// Act
await repository.AddAsync(invitation);
// Assert
Assert.That(context.Invitations.Count, Is.EqualTo(1));
Assert.That(context.Invitations.First(), Is.EqualTo(invitation));
}
[Test]
public async Task Given_InvalidAdmin_When_AddAsync_Should_Throw_AdditionException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<AdditionException>(async () => await repository.AddAsync(default));
}
[Test]
public async Task Given_NotExistInvitesCode_When_Exist_Then_Returns_False()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
// Act
var result = repository.Exist(Guid.NewGuid());
var result2 = repository.Exist(_fixture.Create<string>());
Assert.That(result, Is.False);
Assert.That(result2, Is.False);
}
[Test]
public async Task Given_ExistInvites_When_Exist_Then_Returns_False()
{
// Arrange
var invitation = _fixture.Create<Invitation>();
invitation.Code = string.Join("", _fixture.CreateMany<char>(12));
invitation.EndDate = invitation.DateCreated.AddHours(1);
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
context.Invitations.Add(invitation);
await context.SaveChangesAsync();
// Act
var result = repository.Exist(invitation.Id);
var result2 = repository.Exist(invitation);
var result3 = repository.Exist(invitation.Code);
Assert.That(result, Is.True);
Assert.That(result2, Is.True);
Assert.That(result3, Is.True);
}
[Test]
public async Task Given_InvalidInvites_When_Exist_Then_Returns_False()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new InvitesRepository(context, _validator);
// Act & Assert
Assert.Throws<InvalidObjectException<Invitation>>(() => repository.Exist(default(Invitation)));
}
}
@@ -1,249 +0,0 @@
using AutoFixture;
using Govor.Domain.Infrastructure.Validators;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Govor.Domain;
using Govor.Domain.Repositories;
using Govor.Domain.Repositories.Exceptions;
using Microsoft.EntityFrameworkCore;
namespace Govor.Domain.Tests.Repositories;
[TestFixture]
public class MediaAttachmentsTests
{
private Fixture _fixture;
private DbContextOptions<GovorDbContext> _options;
private readonly IObjectValidator<MediaAttachments> _validator = new MediaAttachmentsValidator();
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(MediaAttachmentsTests)}_{_testIteration}")
.Options;
}
[Test]
public async Task Given_NotEmptySetDb_When_GetAll_Then_ReturnAllAttachments()
{
// Arrange
var random = new Random();
var attachments = _fixture.CreateMany<MediaAttachments>(random.Next(2, 10)).ToList();
await using var context = new GovorDbContext(_options);
var attachmentsRepository = new MediaAttachmentsRepository(context, _validator);
context.MediaAttachments.AddRange(attachments);
await context.SaveChangesAsync();
// Act
var result = await attachmentsRepository.GetAllAsync();
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.EqualTo(attachments.Count));
Assert.That(result, Is.EquivalentTo(attachments));
}
[Test]
public void Given_EmptySetDb_When_GetAll_Should_Throw_NotFoundException()
{
// Arrange
using var context = new GovorDbContext(_options);
var mediaAttachments = new MediaAttachmentsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundException>(async () => await mediaAttachments.GetAllAsync());
}
[Test]
public async Task Given_ValidMessageId_When_GetAllByMessageId_Then_ReturnAllAttachments()
{
// Arrange
var random = new Random();
var attachments = _fixture.CreateMany<MediaAttachments>(random.Next(2, 10)).ToList();
await using var context = new GovorDbContext(_options);
var attachmentsRepository = new MediaAttachmentsRepository(context, _validator);
context.MediaAttachments.AddRange(attachments);
await context.SaveChangesAsync();
// Act
var result = await attachmentsRepository.GetAllByMessageId(attachments.First().MessageId);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.EqualTo(1));
Assert.That(result.First(), Is.EqualTo(attachments.First()));
}
[Test]
public async Task Given_InvalidMessageId_When_GetAllByMessageId_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var attachmentsRepository = new MediaAttachmentsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await attachmentsRepository.GetAllByMessageId(_fixture.Create<Guid>()));
}
[Test]
public async Task Given_ValidAttachmentsId_When_FindByIdAsync_Then_Returns_Attachment()
{
// Arrange
var attachment = _fixture.Create<MediaAttachments>();
await using var context = new GovorDbContext(_options);
var attachmentsRepository = new MediaAttachmentsRepository(context, _validator);
context.MediaAttachments.Add(attachment);
await context.SaveChangesAsync();
// Act
var result = await attachmentsRepository.FindByIdAsync(attachment.Id);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(attachment));
}
[Test]
public async Task Given_InvalidAttachmentsId_When_FindByIdAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var attachmentsRepository = new MediaAttachmentsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await attachmentsRepository.FindByIdAsync(_fixture.Create<Guid>()));
}
[Test]
public async Task Given_ValidAttachments_When_AddAsync_Then_AttachmentsAdded()
{
// Arrange
var attachments = _fixture.Create<MediaAttachments>();
await using var context = new GovorDbContext(_options);
var messagesRepository = new MediaAttachmentsRepository(context, _validator);
// Act
await messagesRepository.AddAsync(attachments);
// Assert
Assert.That(context.MediaAttachments.Count, Is.EqualTo(1));
Assert.That(context.MediaAttachments.First(), Is.EqualTo(attachments));
}
[Test]
public async Task Given_InvalidAttachments_When_AddAsync_Should_Throw_AdditionException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new MediaAttachmentsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<AdditionException>(async () => await repository.AddAsync(default));
}
[Test]
public async Task Given_ExistAttachment_When_Exist_Then_ReturnTrue()
{
// Arrange
var attachments = _fixture.Create<MediaAttachments>();
await using var context = new GovorDbContext(_options);
var repository = new MediaAttachmentsRepository(context, _validator);
context.MediaAttachments.Add(attachments);
await context.SaveChangesAsync();
// Act
var result = repository.Exist(attachments);
var result2 = repository.Exist(attachments.Id);
// Assert
Assert.That(result, Is.True);
Assert.That(result2, Is.True);
}
[Test]
public async Task Given_NotExistMessage_When_Exist_Then_ReturnFalse()
{
// Arrange
var attachments = _fixture.Create<MediaAttachments>();
await using var context = new GovorDbContext(_options);
var repository = new MediaAttachmentsRepository(context, _validator);
// Act
var result = repository.Exist(attachments);
var result2 = repository.Exist(attachments.Id);
// Assert
Assert.That(result, Is.False);
Assert.That(result2, Is.False);
}
[Test]
public async Task Given_NotEqualMessage_When_Exist_Then_ReturnFalse()
{
// Arrange
var attachments = _fixture.Create<MediaAttachments>();
var attachments2 = _fixture.Create<MediaAttachments>();
attachments2.Id = attachments.Id;
await using var context = new GovorDbContext(_options);
var repository = new MediaAttachmentsRepository(context, _validator);
context.MediaAttachments.Add(attachments);
await context.SaveChangesAsync();
// Act
var result = repository.Exist(attachments2);
// Assert
Assert.That(result, Is.False);
}
[Test]
public async Task Given_InvalidMessage_When_Exist_Should_Throw_InvalidObjectException()
{
// Arrange
var attachments = _fixture.Create<MediaAttachments>();
attachments.MessageId = Guid.Empty;
await using var context = new GovorDbContext(_options);
var repository = new MediaAttachmentsRepository(context, _validator);
// Act & Assert
Assert.Throws<InvalidObjectException<MediaAttachments>>(() => repository.Exist(attachments));
}
[Test]
public void Given_NullMessage_When_Exist_Should_Throw_InvalidObjectException()
{
using var context = new GovorDbContext(_options);
var repository = new MediaAttachmentsRepository(context, _validator);
// Act & Assert
Assert.Throws<InvalidObjectException<MediaAttachments>>(() => repository.Exist(default(MediaAttachments)));
}
}
@@ -1,398 +0,0 @@
using AutoFixture;
using Govor.Domain.Infrastructure.Validators;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Govor.Domain;
using Govor.Domain.Repositories;
using Govor.Domain.Repositories.Exceptions;
using Microsoft.EntityFrameworkCore;
namespace Govor.Domain.Tests.Repositories;
[TestFixture]
public class MessagesRepositoryTests
{
private Fixture _fixture;
private DbContextOptions<GovorDbContext> _options;
private readonly IObjectValidator<Message> _messageValidator = new MessageValidator();
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(MessagesRepositoryTests)}_{_testIteration}")
.Options;
}
[Test]
public async Task Given_NotEmptySetDb_When_GetAllMessages_Then_ReturnAllMessages()
{
// Arrange
var random = new Random();
var messages = _fixture.CreateMany<Message>(random.Next(2, 10)).ToList();
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
context.Messages.AddRange(messages);
await context.SaveChangesAsync();
// Act
var result = await messagesRepository.GetAllAsync();
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.EqualTo(messages.Count));
Assert.That(result, Is.EquivalentTo(messages));
}
[Test]
public void Given_EmptySetDb_When_GetAllMessages_Should_Throw_NotFoundException()
{
// Arrange
using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
// Act & Assert
Assert.ThrowsAsync<NotFoundException>(async () => await messagesRepository.GetAllAsync());
}
[Test]
public async Task Given_ValidMessageId_When_FindMessageById_Then_ReturnMessage()
{
// Arrange
var messages = _fixture.CreateMany<Message>(10);
var id = messages.First().Id;
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
context.Messages.AddRange(messages);
await context.SaveChangesAsync();
// Act
var result = await messagesRepository.FindByIdAsync(id);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(messages.First()));
}
[Test]
public async Task Given_InvalidMessageId_When_FindById_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await messagesRepository.FindByIdAsync(_fixture.Create<Guid>()));
}
[Test]
public async Task Given_ValidSenderId_When_FindBySenderIdAsync_Then_ReturnMessages()
{
// Arrange
var messages = _fixture.CreateMany<Message>(10).ToList();
var senderId =_fixture.Create<Guid>();
foreach (var message in messages)
{
message.SenderId = senderId;
}
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
context.Messages.AddRange(messages);
await context.SaveChangesAsync();
// Act
var results = await messagesRepository.FindBySenderIdAsync(senderId);
// Assert
Assert.That(results, Is.Not.Null);
Assert.That(results, Is.EquivalentTo(messages));
}
[Test]
public void Given_InvalidSenderId_When_FindBySenderId_Should_Throw_NotFoundByKeyException()
{
// Arrange
using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await messagesRepository.FindBySenderIdAsync(_fixture.Create<Guid>()));
}
[Test]
public async Task Given_ValidReceiverId_When_FindByReceiverIdAsync_Then_ReturnMessages()
{
// Arrange
var messages = _fixture.CreateMany<Message>(10).ToList();
var receiverId =_fixture.Create<Guid>();
foreach (var message in messages)
{
message.RecipientId = receiverId;
}
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
context.Messages.AddRange(messages);
await context.SaveChangesAsync();
// Act
var results = await messagesRepository.FindByReceiverIdAsync(receiverId);
// Assert
Assert.That(results, Is.Not.Null);
Assert.That(results, Is.EquivalentTo(messages));
}
[Test]
public void Given_InvalidReceiverId_When_FindByReceiverIdAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await messagesRepository.FindByReceiverIdAsync(_fixture.Create<Guid>()));
}
[Test]
public async Task Given_ValidSenderIdReceiverIdAndReceiverType_When_FindBySenderAndReceiverIdAsync_Then_ReturnMessages()
{
// Arrange
var messages = _fixture.CreateMany<Message>(10).ToList();
var receiverId =_fixture.Create<Guid>();
var senderId =_fixture.Create<Guid>();
RecipientType recipientType =_fixture.Create<RecipientType>();
foreach (var message in messages)
{
message.RecipientId = receiverId;
message.SenderId = senderId;
message.RecipientType = recipientType;
}
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
context.Messages.AddRange(messages);
await context.SaveChangesAsync();
// Act
var results = await messagesRepository.FindBySenderAndReceiverIdAsync(senderId, receiverId, recipientType);
Assert.That(results, Is.Not.Null);
Assert.That(results, Is.EquivalentTo(messages));
}
[Test]
public async Task Given_InvalidSenderId_When_FindBySenderAndReceiverIdAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
var messages = _fixture.CreateMany<Message>(10).ToList();
var receiverId =_fixture.Create<Guid>();
var senderId =_fixture.Create<Guid>();
RecipientType recipientType =_fixture.Create<RecipientType>();
foreach (var message in messages)
{
message.RecipientId = receiverId;
message.RecipientType = recipientType;
}
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
context.Messages.AddRange(messages);
await context.SaveChangesAsync();
// Act & Assert
Assert.ThrowsAsync<NotFoundException>(async () => await messagesRepository.FindBySenderAndReceiverIdAsync(senderId, receiverId, recipientType));
}
[Test]
public async Task Given_InvalidReceiverId_When_FindBySenderAndReceiverIdAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
var messages = _fixture.CreateMany<Message>(10).ToList();
var receiverId =_fixture.Create<Guid>();
var senderId =_fixture.Create<Guid>();
RecipientType recipientType =_fixture.Create<RecipientType>();
foreach (var message in messages)
{
message.SenderId = senderId;
message.RecipientType = recipientType;
}
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
context.Messages.AddRange(messages);
await context.SaveChangesAsync();
// Act & Assert
Assert.ThrowsAsync<NotFoundException>(async () => await messagesRepository.FindBySenderAndReceiverIdAsync(senderId, receiverId, recipientType));
}
[Test]
public async Task Given_ValidDateTime_When_FindByValidDateTimeAsync_Then_ReturnMessages()
{
// Assert
var messages = _fixture.CreateMany<Message>(10).ToList();
var dateTime = _fixture.Create<DateTime>();
foreach (var message in messages)
{
message.SentAt = dateTime;
}
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
context.Messages.AddRange(messages);
await context.SaveChangesAsync();
// Act
var results = await messagesRepository.FindBySentAtAsync(dateTime);
// Assert
Assert.That(results, Is.Not.Null);
Assert.That(results, Is.EquivalentTo(messages));
}
[Test]
public async Task Given_ValidMessage_When_AddAsync_Then_MessageAdded()
{
// Arrange
var message = _fixture.Create<Message>();
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
// Act
await messagesRepository.AddAsync(message);
// Assert
Assert.That(context.Messages.Count, Is.EqualTo(1));
Assert.That(context.Messages.First(), Is.EqualTo(message));
}
[Test]
public async Task Given_InvalidMessage_When_AddAsync_Should_Throw_AdditionException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
// Act & Assert
Assert.ThrowsAsync<AdditionException>(async () => await messagesRepository.AddAsync(default));
}
[Test]
public async Task Given_ExistMessage_When_Exist_Then_ReturnTrue()
{
// Arrange
var message = _fixture.Create<Message>();
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
context.Messages.Add(message);
await context.SaveChangesAsync();
// Act
var result = messagesRepository.Exist(message);
var result2 = messagesRepository.Exist(message.Id);
// Assert
Assert.That(result, Is.True);
Assert.That(result2, Is.True);
}
[Test]
public async Task Given_NotExistMessage_When_Exist_Then_ReturnFalse()
{
// Arrange
var message = _fixture.Create<Message>();
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
// Act
var result = messagesRepository.Exist(message);
var result2 = messagesRepository.Exist(message.Id);
// Assert
Assert.That(result, Is.False);
Assert.That(result2, Is.False);
}
[Test]
public async Task Given_NotEqualMessage_When_Exist_Then_ReturnFalse()
{
// Arrange
var message = _fixture.Create<Message>();
var message2 = _fixture.Create<Message>();
message.Id = message2.Id;
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
context.Messages.Add(message);
await context.SaveChangesAsync();
// Act
var result = messagesRepository.Exist(message2);
// Assert
Assert.That(result, Is.False);
}
[Test]
public async Task Given_InvalidMessage_When_Exist_Should_Throw_InvalidObjectException()
{
// Arrange
var message = _fixture.Create<Message>();
message.SentAt = DateTime.MinValue;
message.RecipientId = Guid.Empty;
await using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
// Act & Assert
Assert.Throws<InvalidObjectException<Message>>(() => messagesRepository.Exist(message));
}
[Test]
public void Given_NullMessage_When_Exist_Should_Throw_InvalidObjectException()
{
using var context = new GovorDbContext(_options);
var messagesRepository = new MessagesRepository(context, _messageValidator);
// Act & Assert
Assert.Throws<InvalidObjectException<Message>>(() => messagesRepository.Exist(default(Message)));
}
}
@@ -1,203 +0,0 @@
using AutoFixture;
using Govor.Domain.Infrastructure.Validators;
using Govor.Domain.Models;
using Govor.Domain;
using Govor.Domain.Repositories;
using Govor.Domain.Repositories.Exceptions;
using Microsoft.EntityFrameworkCore;
namespace Govor.Domain.Tests.Repositories;
[TestFixture]
public class PrivateChatsRepositoryTests
{
private Fixture _fixture;
private DbContextOptions<GovorDbContext> _options;
private IObjectValidator<PrivateChat> _validator = new PrivateChatValidator();
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(PrivateChatsRepositoryTests)}_{_testIteration}")
.Options;
}
[Test]
public async Task Given_NotEmptySetDb_When_GetAll_Then_ReturnAll()
{
// Arrange
var random = new Random();
var chats = _fixture.CreateMany<PrivateChat>(random.Next(2, 10)).ToList();
await using var context = new GovorDbContext(_options);
var repository = new PrivateChatsRepository(context, _validator);
context.PrivateChats.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 PrivateChatsRepository(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<PrivateChat>(10);
var id = chats.First().Id;
await using var context = new GovorDbContext(_options);
var repository = new PrivateChatsRepository(context, _validator);
context.PrivateChats.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 async Task Given_InvalidMessageId_When_FindById_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new PrivateChatsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await repository.GetByIdAsync(_fixture.Create<Guid>()));
}
[Test]
public async Task Given_MembersId_When_GetByMembersAsync_Then_ReturnChat()
{
// Arrange
var chats = _fixture.CreateMany<PrivateChat>(10);
var id1 = chats.First().UserAId;
var id2 = chats.First().UserBId;
await using var context = new GovorDbContext(_options);
var repository = new PrivateChatsRepository(context, _validator);
context.PrivateChats.AddRange(chats);
await context.SaveChangesAsync();
// Act
var result = await repository.GetByMembersAsync(id1, id2);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(chats.First()));
}
[Test]
public async Task Given_InvalidMembersId_When_GetByMembersAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new PrivateChatsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<(Guid, Guid)>>(async () => await repository.GetByMembersAsync(_fixture.Create<Guid>(), _fixture.Create<Guid>()));
}
[Test]
public async Task Given_ValidPrivateChat_When_AddAsync_Then_PrivateChatAdded()
{
// Arrange
var chat = _fixture.Create<PrivateChat>();
await using var context = new GovorDbContext(_options);
var repository = new PrivateChatsRepository(context, _validator);
// Act
await repository.AddAsync(chat);
// Assert
Assert.That(context.PrivateChats.Count, Is.EqualTo(1));
Assert.That(context.PrivateChats.First(), Is.EqualTo(chat));
}
[Test]
public async Task Given_InvalidPrivateChat_When_AddAsync_Should_Throw_AdditionException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new PrivateChatsRepository(context, _validator);
// Act & Assert
Assert.ThrowsAsync<AdditionException>(async () => await repository.AddAsync(default));
}
[Test]
public async Task Given_ExistPrivateChat_When_Exist_Then_ReturnTrue()
{
// Arrange
var chat = _fixture.Create<PrivateChat>();
await using var context = new GovorDbContext(_options);
var repository = new PrivateChatsRepository(context, _validator);
context.PrivateChats.Add(chat);
await context.SaveChangesAsync();
// Act
var result1 = repository.Exist(chat.UserAId, chat.UserBId);
var result2 = repository.Exist(chat.Id);
// Assert
Assert.That(result1, Is.True);
Assert.That(result2, Is.True);
}
[Test]
public async Task Given_NotExistPrivateChat_When_Exist_Then_ReturnFalse()
{
// Arrange
var chat = _fixture.Create<PrivateChat>();
await using var context = new GovorDbContext(_options);
var repository = new PrivateChatsRepository(context, _validator);
// Act
var result1 = repository.Exist(chat.UserAId, chat.UserBId);
var result2 = repository.Exist(chat.Id);
// Assert
Assert.That(result1, Is.False);
Assert.That(result2, Is.False);
}
}
@@ -1,233 +0,0 @@
using Govor.Domain.Models.Users;
using Govor.Domain.Repositories;
using Microsoft.EntityFrameworkCore;
namespace Govor.Domain.Tests.Repositories;
[TestFixture]
public class PushTokenRepositoryTests
{
private GovorDbContext _context;
private PushTokenRepository _repository;
[SetUp]
public void Setup()
{
var options = new DbContextOptionsBuilder<GovorDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
_context = new GovorDbContext(options);
_repository = new PushTokenRepository(_context);
}
[TearDown]
public void TearDown()
{
_context.Dispose();
}
#region GetActiveTokensAsync
[Test]
public async Task GetActiveTokensAsync_ReturnsUserTokens()
{
var userId = Guid.NewGuid();
_context.UserPushTokens.Add(new UserPushToken
{
UserId = userId,
Token = "token1",
IsActive = true
});
await _context.SaveChangesAsync();
var result = await _repository.GetActiveTokensAsync(userId);
Assert.That(result, Contains.Item("token1"));
}
#endregion
#region GetActiveTokensUsersAsync
[Test]
public async Task GetActiveTokensUsersAsync_ReturnsDistinctActiveTokens()
{
var user1 = Guid.NewGuid();
var user2 = Guid.NewGuid();
_context.UserPushTokens.AddRange(
new UserPushToken { UserId = user1, Token = "t1", IsActive = true },
new UserPushToken { UserId = user2, Token = "t2", IsActive = true },
new UserPushToken { UserId = user2, Token = "inactive", IsActive = false }
);
await _context.SaveChangesAsync();
var result = await _repository.GetActiveTokensUsersAsync([user1, user2, user1]);
Assert.That(result.Count, Is.EqualTo(2));
Assert.That(result, Does.Not.Contain("inactive"));
}
[Test]
public async Task GetActiveTokensUsersAsync_EmptyInput_ReturnsEmpty()
{
var result = await _repository.GetActiveTokensUsersAsync([]);
Assert.That(result, Is.Empty);
}
#endregion
#region GetActiveTokenBySessionAsync
[Test]
public async Task GetActiveTokenBySessionAsync_ReturnsToken()
{
var sessionId = Guid.NewGuid();
_context.UserPushTokens.Add(new UserPushToken
{
UserSessionId = sessionId,
Token = "sessionToken",
IsActive = true
});
await _context.SaveChangesAsync();
var result = await _repository.GetActiveTokenBySessionAsync(sessionId);
Assert.That(result, Is.EqualTo("sessionToken"));
}
[Test]
public async Task GetActiveTokenBySessionAsync_EmptySession_ReturnsEmptyString()
{
var result = await _repository.GetActiveTokenBySessionAsync(Guid.Empty);
Assert.That(result, Is.EqualTo(""));
}
#endregion
#region AddOrUpdateTokenAsync
[Test]
public void AddOrUpdateTokenAsync_InvalidUserId_Throws()
{
Assert.ThrowsAsync<ArgumentException>(() =>
_repository.AddOrUpdateTokenAsync(Guid.Empty, null, "token", "android"));
}
[Test]
public void AddOrUpdateTokenAsync_EmptyToken_Throws()
{
Assert.ThrowsAsync<ArgumentException>(() =>
_repository.AddOrUpdateTokenAsync(Guid.NewGuid(), null, "", "android"));
}
[Test]
public async Task AddOrUpdateTokenAsync_AddsNewToken()
{
var userId = Guid.NewGuid();
await _repository.AddOrUpdateTokenAsync(userId, null, "newToken", "android");
var token = await _context.UserPushTokens.FirstOrDefaultAsync();
Assert.That(token, Is.Not.Null);
Assert.That(token!.UserId, Is.EqualTo(userId));
Assert.That(token.IsActive, Is.True);
}
[Test]
public async Task AddOrUpdateTokenAsync_UpdatesExistingToken()
{
var userId = Guid.NewGuid();
var existing = new UserPushToken
{
UserId = Guid.NewGuid(),
Token = "sameToken",
Platform = "ios",
IsActive = false
};
_context.UserPushTokens.Add(existing);
await _context.SaveChangesAsync();
await _repository.AddOrUpdateTokenAsync(userId, null, "sameToken", "android");
var updated = await _context.UserPushTokens.FirstAsync();
Assert.That(updated.UserId, Is.EqualTo(userId));
Assert.That(updated.Platform, Is.EqualTo("android"));
Assert.That(updated.IsActive, Is.True);
}
#endregion
#region RemoveTokensAsync
[Test]
public async Task RemoveTokensAsync_RemovesTokens()
{
_context.UserPushTokens.Add(new UserPushToken
{
Token = "t1",
UserId = Guid.NewGuid()
});
await _context.SaveChangesAsync();
await _repository.RemoveTokensAsync(["t1"]);
Assert.That(_context.UserPushTokens.Count(), Is.EqualTo(0));
}
[Test]
public async Task RemoveTokensAsync_EmptyInput_DoesNothing()
{
await _repository.RemoveTokensAsync([]);
Assert.Pass();
}
#endregion
#region DeactivateTokenBySessionAsync
[Test]
public async Task DeactivateTokenBySessionAsync_DeactivatesTokens()
{
var sessionId = Guid.NewGuid();
_context.UserPushTokens.Add(new UserPushToken
{
UserSessionId = sessionId,
Token = "t1",
IsActive = true
});
await _context.SaveChangesAsync();
await _repository.DeactivateTokenBySessionAsync(sessionId);
var token = await _context.UserPushTokens.FirstAsync();
Assert.That(token.IsActive, Is.False);
}
[Test]
public async Task DeactivateTokenBySessionAsync_EmptySession_DoesNothing()
{
await _repository.DeactivateTokenBySessionAsync(Guid.Empty);
Assert.Pass();
}
#endregion
}
@@ -1,310 +0,0 @@
using AutoFixture;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Govor.Domain.Repositories;
using Govor.Domain.Repositories.Exceptions;
using Microsoft.EntityFrameworkCore;
namespace Govor.Domain.Tests.Repositories;
[TestFixture]
public class UserSessionsRepositoryTests
{
private Fixture _fixture;
private DbContextOptions<GovorDbContext> _options;
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(UserSessionsRepositoryTests)}_{_testIteration}")
.Options;
}
[Test]
public async Task GetAllSessions_ReturnsAllSessions()
{
// Arrange
var random = new Random();
var sessions = _fixture.CreateMany<UserSession>(random.Next(2, 10)).ToList();
await using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
context.UserSessions.AddRange(sessions);
await context.SaveChangesAsync();
// Act
var result = await repository.GetAllAsync();
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.EqualTo(sessions.Count));
Assert.That(result, Is.EquivalentTo(sessions));
}
[Test]
public void Given_EmptySetDb_When_GetAll_Should_Throw_NotFoundException()
{
// Arrange
using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
// Act & Assert
Assert.ThrowsAsync<NotFoundException>(async () => await repository.GetAllAsync());
}
[Test]
public async Task Given_ValidId_When_GetByIdAsync_ShouldReturnSession()
{
// Arrange
var random = new Random();
var sessions = _fixture.CreateMany<UserSession>(random.Next(2, 10)).ToList();
var id = sessions.First().Id;
await using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
context.UserSessions.AddRange(sessions);
await context.SaveChangesAsync();
// Act
var result = await repository.GetByIdAsync(id);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Id, Is.EqualTo(id));
Assert.That(result, Is.EqualTo(sessions.First()));
}
[Test]
public void Given_InvalidId_When_GetByIdAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await repository.GetByIdAsync(_fixture.Create<Guid>()));
}
[Test]
public async Task Given_ValidCreatedAt_When_GetByCreatedAtAsync_ShouldReturnSession()
{
// Arrange
var random = new Random();
var sessions = _fixture.CreateMany<UserSession>(random.Next(2, 10)).ToList();
var created = sessions.First().CreatedAt;
await using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
context.UserSessions.AddRange(sessions);
await context.SaveChangesAsync();
// Act
var list = await repository.GetByCreatedAtAsync(created);
// Assert
var result = list.First();
Assert.That(result, Is.Not.Null);
Assert.That(result.CreatedAt, Is.EqualTo(created));
Assert.That(result, Is.EqualTo(sessions.First()));
}
[Test]
public void Given_ValidCreatedAt_When_GetByCreatedAtAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<DateTime>>(async () => await repository.GetByCreatedAtAsync(_fixture.Create<DateTime>()));
}
[Test]
public async Task Given_ValidExpiresAt_When_GetByExpiresAtAsync_ShouldReturnSession()
{
// Arrange
var random = new Random();
var sessions = _fixture.CreateMany<UserSession>(random.Next(2, 10)).ToList();
var expiresAt = sessions.First().ExpiresAt;
await using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
context.UserSessions.AddRange(sessions);
await context.SaveChangesAsync();
// Act
var list = await repository.GetByExpiresAtAsync(expiresAt);
// Assert
var result = list.First();
Assert.That(result, Is.Not.Null);
Assert.That(result.ExpiresAt, Is.EqualTo(expiresAt));
Assert.That(result, Is.EqualTo(sessions.First()));
}
[Test]
public void Given_ValidExpiresAt_When_GetByExpiresAtAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<DateTime>>(async () => await repository.GetByExpiresAtAsync(_fixture.Create<DateTime>()));
}
[Test]
public async Task Given_isRevoked_When_GetByRevokedAsync_ShouldReturnSession()
{
// Arrange
var random = new Random();
var sessions = _fixture.Build<UserSession>()
.With(f => f.IsRevoked, true)
.CreateMany(random.Next(2, 10)).ToList();
var isRevoke = sessions.First().IsRevoked;
await using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
context.UserSessions.AddRange(sessions);
await context.SaveChangesAsync();
// Act
var result = await repository.GetByRevokedAsync(isRevoke);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EquivalentTo(sessions));
}
[Test]
public void Given_InvalidRevoked_When_GetByExpiresAtAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<bool>>(async () => await repository.GetByRevokedAsync(false));
}
[Test]
public async Task Given_ValidRefreshToken_When_GetByRefreshTokenAsync_ShouldReturnSession()
{
// Arrange
var random = new Random();
var sessions = _fixture.Build<UserSession>()
.With(f => f.IsRevoked, true)
.CreateMany(random.Next(2, 10)).ToList();
var token = sessions.First().RefreshTokenHash;
await using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
context.UserSessions.AddRange(sessions);
await context.SaveChangesAsync();
// Act
var result = await repository.GetByHashedRefreshTokenAsync(token);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(sessions.First()));
}
[Test]
public void Given_InvalidRefreshToken_When_GetByRefreshTokenAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<string>>(async () => await repository.GetByHashedRefreshTokenAsync(_fixture.Create<string>()));
}
[Test]
public async Task Given_ValidUserSessions_When_AddAsync_Then_UserSessionsAdded()
{
// Arrange
var session = _fixture.Create<UserSession>();
await using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
// Act
await repository.AddAsync(session);
// Assert
Assert.That(context.UserSessions.Count, Is.EqualTo(1));
Assert.That(context.UserSessions.First(), Is.EqualTo(session));
}
[Test]
public async Task Given_InvalidUserSessions_When_AddAsync_Should_Throw_AdditionException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
// Act & Assert
Assert.ThrowsAsync<AdditionException>(async () => await repository.AddAsync(default));
}
[Test]
public async Task Given_ExistUserSessions_When_Exist_Then_ReturnTrue()
{
// Arrange
var session = _fixture.Create<UserSession>();
await using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
context.UserSessions.Add(session);
await context.SaveChangesAsync();
// Act
var result1 = repository.Exist(session);
var result2 = repository.Exist(session.Id);
var result3 = repository.Exist(session.RefreshTokenHash);
// Assert
Assert.That(result1, Is.True);
Assert.That(result2, Is.True);
Assert.That(result3, Is.True);
}
[Test]
public async Task Given_NotExistUserSessions_When_Exist_Then_ReturnFalse()
{
// Arrange
var session = _fixture.Create<UserSession>();
await using var context = new GovorDbContext(_options);
var repository = new UserSessionsRepository(context);
// Act
var result1 = repository.Exist(session);
var result2 = repository.Exist(session.Id);
var result3 = repository.Exist(session.RefreshTokenHash);
// Assert
Assert.That(result1, Is.False);
Assert.That(result2, Is.False);
Assert.That(result3, Is.False);
}
}
@@ -1,425 +0,0 @@
using AutoFixture;
using Govor.Domain.Infrastructure.Validators;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Govor.Domain;
using Govor.Domain.Repositories;
using Govor.Domain.Repositories.Exceptions;
using Microsoft.EntityFrameworkCore;
namespace Govor.Domain.Tests.Repositories;
[TestFixture]
public class UsersRepositoryTests
{
private Fixture _fixture;
private DbContextOptions<GovorDbContext> _options;
private readonly IObjectValidator<User> _userValidator = new UserValidator();
[SetUp]
public void SetUp()
{
_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")
.Options;
}
[Test]
public async Task GetAll_Then_Returns_All_Users()
{
// Arrange
var random = new Random();
var users = _fixture.CreateMany<User>(random.Next(2, 10)).ToList();
_options = new DbContextOptionsBuilder<GovorDbContext>()
.UseInMemoryDatabase(databaseName: "DbGovor_users_getall")
.Options;
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
context.Users.AddRange(users);
await context.SaveChangesAsync();
// Act
var result = await userRepository.GetAllAsync();
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.EqualTo(users.Count));
Assert.That(result.Select(u => u.Id), Is.EquivalentTo(users.Select(u => u.Id)));
Assert.That(result.Select(u => u.Username), Is.EquivalentTo(users.Select(u => u.Username)));
}
[Test]
public async Task Given_ValidUserId_When_FindById_Then_Returns_User()
{
// Arrange
var user = _fixture.Create<User>();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
context.Users.Add(user);
await context.SaveChangesAsync();
// Act
var result = await userRepository.FindByIdAsync(user.Id);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Username, Is.EqualTo(user.Username));
Assert.That(result.Id, Is.EqualTo(user.Id));
}
[Test]
public async Task Given_InvalidUserId_When_FindById_Should_Throw_NotFoundException()
{
// Arrange
var id = Guid.NewGuid();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<Guid>>(async () => await userRepository.FindByIdAsync(id));
}
[Test]
public async Task Given_RangeValidUserId_When_FindByRangeId_Then_Returns_Users()
{
// Arrange
var random = new Random();
var users = _fixture.CreateMany<User>(random.Next(2, 10)).ToList();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
context.Users.AddRange(users);
await context.SaveChangesAsync();
// Act
var result = await userRepository.FindByRangeIdAsync(users.Select(u => u.Id));
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.EqualTo(users.Count));
Assert.That(result.Select(r => r.Id), Is.EquivalentTo(users.Select(u => u.Id)));
Assert.That(result.Select(u => u.Username), Is.EquivalentTo(users.Select(u => u.Username)));
}
[Test]
public async Task Given_InvalidRangeId_When_FindByRangeId_Should_Throw_NotFoundException()
{
// Arrange
var random = new Random();
var ids = _fixture.CreateMany<Guid>(random.Next(2, 10)).ToList();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<IEnumerable<Guid>>>(async () =>
await userRepository.FindByRangeIdAsync(ids));
}
[Test]
public async Task Given_ValidUsername_When_FindByUsername_Then_Returns_User()
{
// Arrange
var user = _fixture.Create<User>();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
context.Users.Add(user);
await context.SaveChangesAsync();
// Act
var result = await userRepository.FindByUsernameAsync(user.Username);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Username, Is.EqualTo(user.Username));
Assert.That(result.Id, Is.EqualTo(user.Id));
}
[Test]
public async Task Given_InvalidUsername_When_FindByUsername_Should_Throw_NotFoundByKeyException()
{
// Arrange
string username = _fixture.Create<string>();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<string>>(async () => await userRepository.FindByUsernameAsync(username));
}
[Test]
public async Task Given_ValidUsernames_When_FindByRangeUsernames_Then_Returns_Users()
{
// Arrange
var random = new Random();
var users = _fixture.CreateMany<User>(random.Next(3, 10)).ToList();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
context.Users.AddRange(users);
await context.SaveChangesAsync();
// Act
var result = await userRepository.FindByRangeUsernamesAsync(users.Select(u => u.Username));
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Select(u => u.Username), Is.EquivalentTo(users.Select(u => u.Username)));
Assert.That(result.Select(u => u.Id), Is.EquivalentTo(users.Select(u => u.Id)));
}
[Test]
public async Task Given_InvalidUsernames_When_FindByRangeUsernames_Should_Throw_NotFoundByKeyException()
{
// Arrange
var random = new Random();
var usernames = _fixture.CreateMany<string>(random.Next(3, 10)).ToList();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<IEnumerable<string>>>(async () =>
await userRepository.FindByRangeUsernamesAsync(usernames));
}
[Test]
public async Task Given_ValidQuery_When_SearchPotentialFriendsAsync_Then_Returns_Users()
{
// Arrange
var random = new Random();
var users = _fixture.CreateMany<User>(random.Next(3, 10)).ToList();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
context.Users.AddRange(users);
await context.SaveChangesAsync();
// Act
var result = await userRepository.SearchPotentialFriendsAsync(users[1].Id, users[0].Username[..15]);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.EqualTo(1));
Assert.That(result.First().Id, Is.EqualTo(users[0].Id));
}
[Test]
public async Task Given_InvalidQuery_When_SearchPotentialFriendsAsync_Should_Throw_NotFoundByKeyException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<(string,Guid)>>(async () => await
userRepository.SearchPotentialFriendsAsync(_fixture.Create<Guid>(), _fixture.Create<string>()));
}
[Test]
public async Task Given_ValidDateOnly_When_FindByCreatedDate_Then_Returns_Users()
{
// Arrange
var random = new Random();
var users = _fixture.CreateMany<User>(random.Next(3, 10)).ToList();
var selectedDate = users[random.Next(users.Count)].CreatedOn;
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
context.Users.AddRange(users);
await context.SaveChangesAsync();
// Act
var result = await userRepository.FindUsersByCreatedDateAsync(selectedDate);
// Assert
var expectedUsers = users
.Where(u => u.CreatedOn == selectedDate)
.ToList();
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.EqualTo(expectedUsers.Count));
Assert.That(result.Select(u => u.Id), Is.EquivalentTo(expectedUsers.Select(u => u.Id)));
}
[Test]
public async Task Given_InvalidDateOnly_When_FindByCreatedDate_Should_Throw_NotFoundByKeyException()
{
// Arrange
var date = _fixture.Create<DateOnly>();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act & Assert
Assert.ThrowsAsync<NotFoundByKeyException<DateOnly>>(async () =>
await userRepository.FindUsersByCreatedDateAsync(date));
}
[Test]
public async Task Given_ValidUser_When_AddUser_Then_CreateUser()
{
var user = _fixture.Create<User>();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act
userRepository.AddAsync(user);
var res = context.Users.Find(user.Id);
// Assert
Assert.That(res, Is.Not.Null);
Assert.That(res.Username, Is.EqualTo(user.Username));
Assert.That(res.Id, Is.EqualTo(user.Id));
}
[Test]
public async Task Given_InvalidUser_When_AddUser_Should_Throw_AdditionUserException()
{
var user = _fixture.Create<User>();
user.Username = string.Empty;
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act & Assert
Assert.ThrowsAsync<AdditionException>(async () => await userRepository.AddAsync(user));
}
[Test]
public async Task Given_ValidUser_When_ExistUser_Then_True()
{
// Arrange
var user = _fixture.Create<User>();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
context.Users.Add(user);
await context.SaveChangesAsync();
// Act
var res = await userRepository.ExistsAsync(user);
// Assert
Assert.That(res, Is.True);
}
[Test]
public async Task Given_ValidUserButNotInDB_When_ExistUser_Then_False()
{
// Arrange
var user = _fixture.Create<User>();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act
var res = await userRepository.ExistsAsync(user);
// Assert
Assert.That(res, Is.False);
}
[Test]
public async Task Given_InvalidUser_When_ExistUser_Should_Throw_InvalidObjectException()
{
// Arrange
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act & Assert
Assert.ThrowsAsync<InvalidObjectException<User>>(async () => await userRepository.ExistsAsync(default));
}
[Test]
public async Task Given_ValidUserId_When_ExistUserById_Then_True()
{
// Arrange
var user = _fixture.Create<User>();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
context.Users.Add(user);
await context.SaveChangesAsync();
// Act
var res = await userRepository.ExistsByIdAsync(user.Id);
// Assert
Assert.That(res, Is.True);
}
[Test]
public async Task Given_ValidUserIdButNotInDB_When_ExistUser_Then_False()
{
// Arrange
var user = _fixture.Create<User>();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act
var res = await userRepository.ExistsByIdAsync(user.Id);
// Assert
Assert.That(res, Is.False);
}
[Test]
public async Task Given_ValidUsername_When_ExistUserById_Then_True()
{
// Arrange
var user = _fixture.Create<User>();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
context.Users.Add(user);
await context.SaveChangesAsync();
// Act
var res = await userRepository.ExistsUsernameAsync(user.Username);
// Assert
Assert.That(res, Is.True);
}
[Test]
public async Task Given_ValidUsernameButNotInDB_When_ExistUser_Then_False()
{
// Arrange
var user = _fixture.Create<User>();
await using var context = new GovorDbContext(_options);
var userRepository = new UsersRepository(context, _userValidator);
// Act
var res = await userRepository.ExistsUsernameAsync(user.Username);
// Assert
Assert.That(res, Is.False);
}
}
+6 -1
View File
@@ -3,5 +3,10 @@
<Project Path="Govor.Application/Govor.Application.csproj" /> <Project Path="Govor.Application/Govor.Application.csproj" />
<Project Path="Govor.Contracts/Govor.Contracts.csproj" /> <Project Path="Govor.Contracts/Govor.Contracts.csproj" />
<Project Path="Govor.Domain/Govor.Domain.csproj" /> <Project Path="Govor.Domain/Govor.Domain.csproj" />
<Project Path="Govor.Server.Tests/Govor.Server.Tests.csproj" /> <Folder Name="/tests/">
<Project Path="tests/Govor.API.Tests/Govor.API.Tests.csproj" />
<Project Path="tests/Govor.Application.Tests/Govor.Application.Tests.csproj" />
<Project Path="tests/Govor.Domain.Tests/Govor.Domain.Tests.csproj" />
<Project Path="tests/Govor.Server.Tests/Govor.Server.Tests.csproj" />
</Folder>
</Solution> </Solution>
+99 -34
View File
@@ -1,7 +1,5 @@

Microsoft Visual Studio Solution File, Format Version 12.00 Microsoft Visual Studio Solution File, Format Version 12.00
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.API.Tests", "Govor.API.Tests\Govor.API.Tests.csproj", "{15031CBD-F319-4755-BA91-B86F20BD8E37}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.API", "Govor.API\Govor.API.csproj", "{EA8F272F-4276-438A-9DEA-C58860A440AE}" Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.API", "Govor.API\Govor.API.csproj", "{EA8F272F-4276-438A-9DEA-C58860A440AE}"
EndProject EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{4ED5259A-6FB4-4D89-8E6B-4778DC68F7D4}" Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{4ED5259A-6FB4-4D89-8E6B-4778DC68F7D4}"
@@ -15,67 +13,134 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.Contracts", "Govor.Co
EndProject EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.Application", "Govor.Application\Govor.Application.csproj", "{FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}" Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.Application", "Govor.Application\Govor.Application.csproj", "{FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}"
EndProject EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.Application.Tests", "Govor.Application.Tests\Govor.Application.Tests.csproj", "{F56A64DF-2938-4BE0-83F2-B86429F19259}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.Data.Tests", "Govor.Data.Tests\Govor.Data.Tests.csproj", "{CF6B23EC-932A-4998-BA95-C94CAB7B092C}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.ConsoleClient.Tests", "Govor.ConsoleClient.Tests\Govor.ConsoleClient.Tests.csproj", "{B1E79EB6-DBD3-4E82-AB6D-DCFCE6533965}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.Domain", "Govor.Domain\Govor.Domain.csproj", "{868EAA88-A8E8-4508-B264-1AE3576D47C1}" Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.Domain", "Govor.Domain\Govor.Domain.csproj", "{868EAA88-A8E8-4508-B264-1AE3576D47C1}"
EndProject EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SmartRes", "..\SmartRes\SmartRes\SmartRes.csproj", "{3AB1DEB2-131B-476F-B4B7-7F8F5479D2FC}" Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.Server.Tests", "tests\Govor.Server.Tests\Govor.Server.Tests.csproj", "{C2BF62C6-D88C-443B-A698-AECEF314DCE0}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.API.Tests", "tests\Govor.API.Tests\Govor.API.Tests.csproj", "{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.Application.Tests", "tests\Govor.Application.Tests\Govor.Application.Tests.csproj", "{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Govor.Domain.Tests", "tests\Govor.Domain.Tests\Govor.Domain.Tests.csproj", "{D54B34C6-DD49-4963-AF97-50617918134D}"
EndProject EndProject
Global Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU Debug|Any CPU = Debug|Any CPU
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|Any CPU = Release|Any CPU Release|Any CPU = Release|Any CPU
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution GlobalSection(ProjectConfigurationPlatforms) = postSolution
{15031CBD-F319-4755-BA91-B86F20BD8E37}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{15031CBD-F319-4755-BA91-B86F20BD8E37}.Debug|Any CPU.Build.0 = Debug|Any CPU
{15031CBD-F319-4755-BA91-B86F20BD8E37}.Release|Any CPU.ActiveCfg = Release|Any CPU
{15031CBD-F319-4755-BA91-B86F20BD8E37}.Release|Any CPU.Build.0 = Release|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {EA8F272F-4276-438A-9DEA-C58860A440AE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Debug|Any CPU.Build.0 = Debug|Any CPU {EA8F272F-4276-438A-9DEA-C58860A440AE}.Debug|Any CPU.Build.0 = Debug|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Debug|x64.ActiveCfg = Debug|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Debug|x64.Build.0 = Debug|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Debug|x86.ActiveCfg = Debug|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Debug|x86.Build.0 = Debug|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Release|Any CPU.ActiveCfg = Release|Any CPU {EA8F272F-4276-438A-9DEA-C58860A440AE}.Release|Any CPU.ActiveCfg = Release|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Release|Any CPU.Build.0 = Release|Any CPU {EA8F272F-4276-438A-9DEA-C58860A440AE}.Release|Any CPU.Build.0 = Release|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Release|x64.ActiveCfg = Release|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Release|x64.Build.0 = Release|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Release|x86.ActiveCfg = Release|Any CPU
{EA8F272F-4276-438A-9DEA-C58860A440AE}.Release|x86.Build.0 = Release|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4E94907F-BE20-42A6-AB15-637850FEAD11}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Debug|Any CPU.Build.0 = Debug|Any CPU {4E94907F-BE20-42A6-AB15-637850FEAD11}.Debug|Any CPU.Build.0 = Debug|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Debug|x64.ActiveCfg = Debug|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Debug|x64.Build.0 = Debug|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Debug|x86.ActiveCfg = Debug|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Debug|x86.Build.0 = Debug|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Release|Any CPU.ActiveCfg = Release|Any CPU {4E94907F-BE20-42A6-AB15-637850FEAD11}.Release|Any CPU.ActiveCfg = Release|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Release|Any CPU.Build.0 = Release|Any CPU {4E94907F-BE20-42A6-AB15-637850FEAD11}.Release|Any CPU.Build.0 = Release|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Release|x64.ActiveCfg = Release|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Release|x64.Build.0 = Release|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Release|x86.ActiveCfg = Release|Any CPU
{4E94907F-BE20-42A6-AB15-637850FEAD11}.Release|x86.Build.0 = Release|Any CPU
{FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Debug|Any CPU.Build.0 = Debug|Any CPU {FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Debug|Any CPU.Build.0 = Debug|Any CPU
{FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Debug|x64.ActiveCfg = Debug|Any CPU
{FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Debug|x64.Build.0 = Debug|Any CPU
{FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Debug|x86.ActiveCfg = Debug|Any CPU
{FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Debug|x86.Build.0 = Debug|Any CPU
{FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Release|Any CPU.ActiveCfg = Release|Any CPU {FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Release|Any CPU.ActiveCfg = Release|Any CPU
{FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Release|Any CPU.Build.0 = Release|Any CPU {FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Release|Any CPU.Build.0 = Release|Any CPU
{F56A64DF-2938-4BE0-83F2-B86429F19259}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Release|x64.ActiveCfg = Release|Any CPU
{F56A64DF-2938-4BE0-83F2-B86429F19259}.Debug|Any CPU.Build.0 = Debug|Any CPU {FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Release|x64.Build.0 = Release|Any CPU
{F56A64DF-2938-4BE0-83F2-B86429F19259}.Release|Any CPU.ActiveCfg = Release|Any CPU {FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Release|x86.ActiveCfg = Release|Any CPU
{F56A64DF-2938-4BE0-83F2-B86429F19259}.Release|Any CPU.Build.0 = Release|Any CPU {FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E}.Release|x86.Build.0 = Release|Any CPU
{CF6B23EC-932A-4998-BA95-C94CAB7B092C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{CF6B23EC-932A-4998-BA95-C94CAB7B092C}.Debug|Any CPU.Build.0 = Debug|Any CPU
{CF6B23EC-932A-4998-BA95-C94CAB7B092C}.Release|Any CPU.ActiveCfg = Release|Any CPU
{CF6B23EC-932A-4998-BA95-C94CAB7B092C}.Release|Any CPU.Build.0 = Release|Any CPU
{B1E79EB6-DBD3-4E82-AB6D-DCFCE6533965}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{B1E79EB6-DBD3-4E82-AB6D-DCFCE6533965}.Debug|Any CPU.Build.0 = Debug|Any CPU
{B1E79EB6-DBD3-4E82-AB6D-DCFCE6533965}.Release|Any CPU.ActiveCfg = Release|Any CPU
{B1E79EB6-DBD3-4E82-AB6D-DCFCE6533965}.Release|Any CPU.Build.0 = Release|Any CPU
{868EAA88-A8E8-4508-B264-1AE3576D47C1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {868EAA88-A8E8-4508-B264-1AE3576D47C1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{868EAA88-A8E8-4508-B264-1AE3576D47C1}.Debug|Any CPU.Build.0 = Debug|Any CPU {868EAA88-A8E8-4508-B264-1AE3576D47C1}.Debug|Any CPU.Build.0 = Debug|Any CPU
{868EAA88-A8E8-4508-B264-1AE3576D47C1}.Debug|x64.ActiveCfg = Debug|Any CPU
{868EAA88-A8E8-4508-B264-1AE3576D47C1}.Debug|x64.Build.0 = Debug|Any CPU
{868EAA88-A8E8-4508-B264-1AE3576D47C1}.Debug|x86.ActiveCfg = Debug|Any CPU
{868EAA88-A8E8-4508-B264-1AE3576D47C1}.Debug|x86.Build.0 = Debug|Any CPU
{868EAA88-A8E8-4508-B264-1AE3576D47C1}.Release|Any CPU.ActiveCfg = Release|Any CPU {868EAA88-A8E8-4508-B264-1AE3576D47C1}.Release|Any CPU.ActiveCfg = Release|Any CPU
{868EAA88-A8E8-4508-B264-1AE3576D47C1}.Release|Any CPU.Build.0 = Release|Any CPU {868EAA88-A8E8-4508-B264-1AE3576D47C1}.Release|Any CPU.Build.0 = Release|Any CPU
{3AB1DEB2-131B-476F-B4B7-7F8F5479D2FC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {868EAA88-A8E8-4508-B264-1AE3576D47C1}.Release|x64.ActiveCfg = Release|Any CPU
{3AB1DEB2-131B-476F-B4B7-7F8F5479D2FC}.Debug|Any CPU.Build.0 = Debug|Any CPU {868EAA88-A8E8-4508-B264-1AE3576D47C1}.Release|x64.Build.0 = Release|Any CPU
{3AB1DEB2-131B-476F-B4B7-7F8F5479D2FC}.Release|Any CPU.ActiveCfg = Release|Any CPU {868EAA88-A8E8-4508-B264-1AE3576D47C1}.Release|x86.ActiveCfg = Release|Any CPU
{3AB1DEB2-131B-476F-B4B7-7F8F5479D2FC}.Release|Any CPU.Build.0 = Release|Any CPU {868EAA88-A8E8-4508-B264-1AE3576D47C1}.Release|x86.Build.0 = Release|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Debug|Any CPU.Build.0 = Debug|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Debug|x64.ActiveCfg = Debug|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Debug|x64.Build.0 = Debug|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Debug|x86.ActiveCfg = Debug|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Debug|x86.Build.0 = Debug|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Release|Any CPU.ActiveCfg = Release|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Release|Any CPU.Build.0 = Release|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Release|x64.ActiveCfg = Release|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Release|x64.Build.0 = Release|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Release|x86.ActiveCfg = Release|Any CPU
{C2BF62C6-D88C-443B-A698-AECEF314DCE0}.Release|x86.Build.0 = Release|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Debug|Any CPU.Build.0 = Debug|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Debug|x64.ActiveCfg = Debug|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Debug|x64.Build.0 = Debug|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Debug|x86.ActiveCfg = Debug|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Debug|x86.Build.0 = Debug|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Release|Any CPU.ActiveCfg = Release|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Release|Any CPU.Build.0 = Release|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Release|x64.ActiveCfg = Release|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Release|x64.Build.0 = Release|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Release|x86.ActiveCfg = Release|Any CPU
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83}.Release|x86.Build.0 = Release|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Debug|Any CPU.Build.0 = Debug|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Debug|x64.ActiveCfg = Debug|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Debug|x64.Build.0 = Debug|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Debug|x86.ActiveCfg = Debug|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Debug|x86.Build.0 = Debug|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Release|Any CPU.ActiveCfg = Release|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Release|Any CPU.Build.0 = Release|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Release|x64.ActiveCfg = Release|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Release|x64.Build.0 = Release|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Release|x86.ActiveCfg = Release|Any CPU
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643}.Release|x86.Build.0 = Release|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Debug|Any CPU.Build.0 = Debug|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Debug|x64.ActiveCfg = Debug|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Debug|x64.Build.0 = Debug|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Debug|x86.ActiveCfg = Debug|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Debug|x86.Build.0 = Debug|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Release|Any CPU.ActiveCfg = Release|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Release|Any CPU.Build.0 = Release|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Release|x64.ActiveCfg = Release|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Release|x64.Build.0 = Release|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Release|x86.ActiveCfg = Release|Any CPU
{D54B34C6-DD49-4963-AF97-50617918134D}.Release|x86.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection EndGlobalSection
GlobalSection(NestedProjects) = preSolution GlobalSection(NestedProjects) = preSolution
{15031CBD-F319-4755-BA91-B86F20BD8E37} = {4ED5259A-6FB4-4D89-8E6B-4778DC68F7D4}
{EA8F272F-4276-438A-9DEA-C58860A440AE} = {114F53C1-B0AB-4BA0-9E36-0E811D1B3776} {EA8F272F-4276-438A-9DEA-C58860A440AE} = {114F53C1-B0AB-4BA0-9E36-0E811D1B3776}
{4E94907F-BE20-42A6-AB15-637850FEAD11} = {114F53C1-B0AB-4BA0-9E36-0E811D1B3776} {4E94907F-BE20-42A6-AB15-637850FEAD11} = {114F53C1-B0AB-4BA0-9E36-0E811D1B3776}
{FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E} = {114F53C1-B0AB-4BA0-9E36-0E811D1B3776} {FC5EDCA8-FD58-4078-8FB1-2BDBB2F6CA3E} = {114F53C1-B0AB-4BA0-9E36-0E811D1B3776}
{F56A64DF-2938-4BE0-83F2-B86429F19259} = {4ED5259A-6FB4-4D89-8E6B-4778DC68F7D4}
{CF6B23EC-932A-4998-BA95-C94CAB7B092C} = {4ED5259A-6FB4-4D89-8E6B-4778DC68F7D4}
{B1E79EB6-DBD3-4E82-AB6D-DCFCE6533965} = {4ED5259A-6FB4-4D89-8E6B-4778DC68F7D4}
{868EAA88-A8E8-4508-B264-1AE3576D47C1} = {114F53C1-B0AB-4BA0-9E36-0E811D1B3776} {868EAA88-A8E8-4508-B264-1AE3576D47C1} = {114F53C1-B0AB-4BA0-9E36-0E811D1B3776}
{C2BF62C6-D88C-443B-A698-AECEF314DCE0} = {4ED5259A-6FB4-4D89-8E6B-4778DC68F7D4}
{A2D7FE0B-7E2D-425C-BB68-731F9C412C83} = {4ED5259A-6FB4-4D89-8E6B-4778DC68F7D4}
{6A736FA3-CAC5-44AE-8E17-C2C4F2EB6643} = {4ED5259A-6FB4-4D89-8E6B-4778DC68F7D4}
{D54B34C6-DD49-4963-AF97-50617918134D} = {4ED5259A-6FB4-4D89-8E6B-4778DC68F7D4}
EndGlobalSection EndGlobalSection
EndGlobal EndGlobal
+6
View File
@@ -22,3 +22,9 @@ This is my school project that I'm working on in my free time to level up my bac
dock: https://nas-3.gitbook.io/govor-api dock: https://nas-3.gitbook.io/govor-api
Deployment: [Timeweb VPS + GitHub Actions](docs/vps-deployment.md) · [Timeweb App Platform](docs/timeweb-deployment.md). Deployment: [Timeweb VPS + GitHub Actions](docs/vps-deployment.md) · [Timeweb App Platform](docs/timeweb-deployment.md).
## Server tests
Run all current server tests with `dotnet test Govor.Server.slnx -c Release`.
See [tests/README.md](tests/README.md) for the project layout, PostgreSQL setup,
coverage commands and validation limits.
+1 -1
View File
@@ -4,7 +4,7 @@
Проверен master Govor-team/Govor, commit 4603be9f714135e0af72d505d17f3d1709834bea (GitHub и локальный checkout совпали). Изучены контроллеры, хабы, сервисы, DTO, EF-модели, DI, запуск и часть MAUI-интеграции. Старый опубликованный GitBook оставался на ревизии 18.12.2025 и расходился с кодом. Проверен master Govor-team/Govor, commit 4603be9f714135e0af72d505d17f3d1709834bea (GitHub и локальный checkout совпали). Изучены контроллеры, хабы, сервисы, DTO, EF-модели, DI, запуск и часть MAUI-интеграции. Старый опубликованный GitBook оставался на ревизии 18.12.2025 и расходился с кодом.
Сборка API на SDK 10.0.400 успешна: первая сборка 90 предупреждений, 0 ошибок. Restore Govor.API.Tests неуспешен: NU1201, net8.0 → net10.0. Тесты не выполнены; утверждать, что они проходят, нельзя. Производственный сервер, БД, Firebase, Docker и UI на устройствах не проверялись. При исходной диагностике сборка API на SDK 10.0.400 прошла с 90 предупреждениями, но тесты .NET 8 не восстанавливались из-за NU1201. Обновление 24.10.2026: серверные тесты перенесены в `tests`, обновлены до .NET 10; Release-сборка и 710 тестов проходят на SQLite и изолированной PostgreSQL. Покрытие Application: 98,88% строк и 93,53% ветвей. Инструкции и ограничения проверки — в [tests/README.md](../tests/README.md). Production, Firebase и UI на устройствах не проверялись.
Ниже «подтверждено» означает выявлено по конкретному коду или диагностике сборки, а не воспроизведено атакой на живой сервис. Ниже «подтверждено» означает выявлено по конкретному коду или диагностике сборки, а не воспроизведено атакой на живой сервис.
+1 -1
View File
@@ -122,7 +122,7 @@ SecureStorage или потери устройства зашифрованна
## Проверка ## Проверка
```powershell ```powershell
dotnet test Govor.Server.Tests/Govor.Server.Tests.csproj dotnet test tests/Govor.Server.Tests/Govor.Server.Tests.csproj
# В мобильном репозитории: # В мобильном репозитории:
dotnet test Govor.Mobile.Tests/Govor.Mobile.Tests.csproj dotnet test Govor.Mobile.Tests/Govor.Mobile.Tests.csproj
dotnet build Govor.Mobile/Govor.Mobile.csproj -f net10.0-android -p:TargetFrameworks=net10.0-android dotnet build Govor.Mobile/Govor.Mobile.csproj -f net10.0-android -p:TargetFrameworks=net10.0-android
+1 -1
View File
@@ -146,7 +146,7 @@ GET `/api/admin/required-channel` возвращает channelId и allowLeave.
```powershell ```powershell
dotnet ef database update --project Govor.Domain --startup-project Govor.API dotnet ef database update --project Govor.Domain --startup-project Govor.API
dotnet test Govor.Server.Tests/Govor.Server.Tests.csproj -c Release dotnet test tests/Govor.Server.Tests/Govor.Server.Tests.csproj -c Release
``` ```
Миграция `20261003131521_PrimitiveGroupsAndRequiredChannel` добавляет владельца, время создания, настройки сервера, лимиты/отзыв ссылок и уникальные индексы членства/админов/кодов. Старые дубли членства объединяются с сохранением бана; удаляются ссылки на отсутствующих пользователей и роли неактивных участников. Неоднозначные старые коды приглашений отзываются. Известное использование старых ссылок восстанавливается по сохранённым членствам; сведения о ранее вышедших пользователях в старой модели отсутствовали. Миграция `20261003131521_PrimitiveGroupsAndRequiredChannel` добавляет владельца, время создания, настройки сервера, лимиты/отзыв ссылок и уникальные индексы членства/админов/кодов. Старые дубли членства объединяются с сохранением бана; удаляются ссылки на отсутствующих пользователей и роли неактивных участников. Неоднозначные старые коды приглашений отзываются. Известное использование старых ссылок восстанавливается по сохранённым членствам; сведения о ранее вышедших пользователях в старой модели отсутствовали.
+1 -1
View File
@@ -50,6 +50,6 @@
Изменения не требуют новой миграции; в БД должна быть применена существующая `20261003070406_ReliableChatPush`. Изменения не требуют новой миграции; в БД должна быть применена существующая `20261003070406_ReliableChatPush`.
Проверка: `dotnet test Govor.Server.Tests/Govor.Server.Tests.csproj`. Тесты проверяют HTTP API, SQL-очередь/аренду/retry, обработку ошибок и реальную сериализацию Firebase SDK через подменённый HTTP-транспорт. Для PostgreSQL предусмотрена `TEST_POSTGRES_CONNECTION` на отдельную БД с именем, заканчивающимся `_tests`. Эти тесты не подтверждают доставку на физическое устройство. Проверка: `dotnet test tests/Govor.Server.Tests/Govor.Server.Tests.csproj`. Тесты проверяют HTTP API, SQL-очередь/аренду/retry, обработку ошибок и реальную сериализацию Firebase SDK через подменённый HTTP-транспорт. Для PostgreSQL предусмотрена `TEST_POSTGRES_CONNECTION` на отдельную БД с именем, заканчивающимся `_tests`. Эти тесты не подтверждают доставку на физическое устройство.
Лимит пакета и классификация ошибок сверены с [документацией отправки FCM](https://firebase.google.com/docs/cloud-messaging/send/admin-sdk) и [кодами ошибок FCM](https://firebase.google.com/docs/cloud-messaging/error-codes). Лимит пакета и классификация ошибок сверены с [документацией отправки FCM](https://firebase.google.com/docs/cloud-messaging/send/admin-sdk) и [кодами ошибок FCM](https://firebase.google.com/docs/cloud-messaging/error-codes).
+1 -1
View File
@@ -127,7 +127,7 @@ mode: All=0 — все активные реакции; None=1 — новые р
```powershell ```powershell
dotnet ef database update --project Govor.Domain --startup-project Govor.API dotnet ef database update --project Govor.Domain --startup-project Govor.API
dotnet test Govor.Server.Tests/Govor.Server.Tests.csproj -c Release dotnet test tests/Govor.Server.Tests/Govor.Server.Tests.csproj -c Release
``` ```
Миграция `20261003101700_ReactionPacksAndChannelPolicies` создаёт каталог, установки, разрешения канала, версии и базовый пак; старые реакции сохраняются. Она подготовлена, но к вашей рабочей БД автоматически не применялась. Локальные тесты используют SQLite и HTTP pipeline с JWT; SignalR-доставка проверяется через mock транспорта. CI также настроен на PostgreSQL. Реальные устройства/сокеты и PostgreSQL локально не проверены. Миграция `20261003101700_ReactionPacksAndChannelPolicies` создаёт каталог, установки, разрешения канала, версии и базовый пак; старые реакции сохраняются. Она подготовлена, но к вашей рабочей БД автоматически не применялась. Локальные тесты используют SQLite и HTTP pipeline с JWT; SignalR-доставка проверяется через mock транспорта. CI также настроен на PostgreSQL. Реальные устройства/сокеты и PostgreSQL локально не проверены.
+1 -2
View File
@@ -47,10 +47,9 @@ Swagger включён во всех окружениях. UseSwagger обслу
## Что проверено ## Что проверено
Restore API-зависимостей и сборка API завершились. Первая сборка: 90 предупреждений, 0 ошибок. Restore Govor.API.Tests завершился NU1201: net8.0 не может ссылаться на net10.0. Сервер с БД и Firebase не запускался; контейнер и миграции не проверялись. Обновление 24.10.2026: серверные тесты обновлены до .NET 10 и находятся в `tests`. `dotnet test Govor.Server.slnx -c Release` запускает все четыре проекта. Release-сборка и 710 тестов проходят на SQLite и отдельной PostgreSQL с применением миграций. Инструкции и ограничения — в [tests/README.md](../tests/README.md). Production, реальная доставка Firebase и контейнер в рамках этой проверки не запускались.
--- ---
Проверено по исходникам на 03.10.2026, commit `4603be9`. Описано текущее поведение; успешная сборка не означает проверку работающего сервера. Проверено по исходникам на 03.10.2026, commit `4603be9`. Описано текущее поведение; успешная сборка не означает проверку работающего сервера.
Источник: [Govor.API/Program.cs](https://github.com/Govor-team/Govor/blob/4603be9f714135e0af72d505d17f3d1709834bea/Govor.API/Program.cs). Источник: [Govor.API/Program.cs](https://github.com/Govor-team/Govor/blob/4603be9f714135e0af72d505d17f3d1709834bea/Govor.API/Program.cs).
+1 -1
View File
@@ -146,7 +146,7 @@ GET `/api/admin/required-channel` возвращает channelId и allowLeave.
```powershell ```powershell
dotnet ef database update --project Govor.Domain --startup-project Govor.API dotnet ef database update --project Govor.Domain --startup-project Govor.API
dotnet test Govor.Server.Tests/Govor.Server.Tests.csproj -c Release dotnet test tests/Govor.Server.Tests/Govor.Server.Tests.csproj -c Release
``` ```
Миграция `20261003131521_PrimitiveGroupsAndRequiredChannel` добавляет владельца, время создания, настройки сервера, лимиты/отзыв ссылок и уникальные индексы членства/админов/кодов. Старые дубли членства объединяются с сохранением бана; удаляются ссылки на отсутствующих пользователей и роли неактивных участников. Неоднозначные старые коды приглашений отзываются. Известное использование старых ссылок восстанавливается по сохранённым членствам; сведения о ранее вышедших пользователях в старой модели отсутствовали. Миграция `20261003131521_PrimitiveGroupsAndRequiredChannel` добавляет владельца, время создания, настройки сервера, лимиты/отзыв ссылок и уникальные индексы членства/админов/кодов. Старые дубли членства объединяются с сохранением бана; удаляются ссылки на отсутствующих пользователей и роли неактивных участников. Неоднозначные старые коды приглашений отзываются. Известное использование старых ссылок восстанавливается по сохранённым членствам; сведения о ранее вышедших пользователях в старой модели отсутствовали.
+2 -2
View File
@@ -28,12 +28,12 @@ FCM разбивается на пачки до 500. Временный отка
## Сборка и обновление ## Сборка и обновление
Используйте .NET SDK 10 и `Govor.Server.slnx`: она включает актуальный сервер и Govor.Server.Tests, без удалённых проектов и внешнего исходного проекта SmartRes. Бинарный `libs/SmartRes.dll` используется по существующему правилу репозитория. Legacy-тесты net8 в старой solution не перенесены. Используйте .NET SDK 10 и `Govor.Server.slnx`: она включает актуальный сервер и Govor.Server.Tests, без удалённых проектов и внешнего исходного проекта SmartRes. Бинарный `libs/SmartRes.dll` используется по существующему правилу репозитория. Обновление 24.10.2026: серверные тесты перенесены в tests, обновлены до .NET 10 и подключены к обоим solution. Инструкции и результаты — в [tests/README.md](../tests/README.md).
```powershell ```powershell
dotnet restore Govor.Server.slnx dotnet restore Govor.Server.slnx
dotnet build Govor.Server.slnx --no-restore -c Release dotnet build Govor.Server.slnx --no-restore -c Release
dotnet test Govor.Server.Tests/Govor.Server.Tests.csproj --no-build -c Release dotnet test Govor.Server.slnx --no-build -c Release
dotnet ef database update --project Govor.Domain --startup-project Govor.API dotnet ef database update --project Govor.Domain --startup-project Govor.API
``` ```
+86
View File
@@ -0,0 +1,86 @@
# Покрытие Govor.API
Итоговая проверка 24.10.2026: Release-сборка и 710 тестовых случаев проходят
на SQLite и PostgreSQL 17.4 без ошибок и пропусков. На этапе расширения API
добавлены 172 случая: API.Tests вырос с 103 до 271, Server.Tests — с 132 до 136.
Application.Tests содержит 295, Domain.Tests — 8 случаев.
## Измерение
| Область | Строки | Ветви |
| --- | ---: | ---: |
| Исходники API до расширения | 56,14% (1093/1947) | 55,86% (248/444) |
| Исходники API после расширения, SQLite | 98,10% (1910/1947) | 92,34% (410/444) |
| Полная сборка API после расширения, включая генератор | 88,47% (1910/2159) | 63,08% (410/650) |
Исходники API включают Program.cs, конфигурацию DI, контроллеры, хабы, фильтр,
mapping и обработчики уведомлений. Все исполняемые строки контроллеров покрыты;
не все пути условий проверены.
Единственное исключение из порога исходников — файл
`obj/Release/net10.0/Microsoft.AspNetCore.OpenApi.SourceGenerators/Microsoft.AspNetCore.OpenApi.SourceGenerators.XmlCommentGenerator/OpenApiXmlCommentSupport.generated.cs`.
Он генерируется SDK, содержит 212 строк и 206 путей ветвления и не вызывается
текущим Swagger pipeline. Swagger проверяется отдельным HTTP-тестом.
Исключение явно запрашивается параметром `-ExcludeGeneratedSources`; без него
скрипт измеряет полную сборку. JSON в обоих случаях сохраняет EntireAssembly,
а при исключении — также ExcludedFiles. Рабочий код ради процентов не исключался.
## Добавленные проверки
- Административные пользователи и приглашения: DTO, поля, пароль, неизвестный
пользователь, фильтрация активных приглашений, ключ администратора, ошибки.
- Ключи сессий: текущий sid, лимит 100 ключей, невалидная модель, проверка дружбы,
Base64, отсутствие SignedPreKey, исключение использованных ключей.
- Личные чаты: проверка дружбы перед созданием, обе ориентации участников,
запреты и ошибки сервисов.
- Наборы реакций: пользовательские и административные операции, пагинация,
подписки, видимость выключенных наборов, emoji и медиа, лимиты и cancellation.
- Группы: списки, участники, приглашения, отмена приглашения, обязательный канал,
удаление аватара и сообщения; уведомления отправляются после успеха.
- ChatsHub: жизненный цикл, Send/Edit/Remove/Read/ReadChat, реакции, параметры
актёра и времени, вложения, ответы, ошибки и отсутствие лишних уведомлений.
- ProfileHub и PresenceHub: подписки групп, онлайн на первом соединении,
офлайн на последнем, нормализация описания, аватар, адресаты и сбои рассылки.
- HubExceptionFilter: активные и отсутствующие сессии, типизированные и обычные
возвращаемые значения, соответствие исключений статусам.
- Уведомления и push: получатели, уже прочитанные сообщения, отсутствующий профиль,
постоянные и временные ошибки поиска чата, отмена с сохранением lease для повтора.
- DI и worker: PostgreSQL provider и retry, detailed errors, отключённый Firebase,
LocalStorage, освобождение scope и остановка при отмене.
- HTTP: административные роли, реальные mappings реакций, регистрация E2EE,
неизменяемость ключей, каталог участников, ping, readiness и Swagger contract.
Проверки SQL-поведения находятся в Integration, тесты с mocks — в Unit.
HTTP-проверки приложения находятся в Govor.Server.Tests/Api. Удалены 32 пустых
каталога старой структуры; это были остатки переноса, а не незавершённые тесты.
## Запуск и CI
```powershell
dotnet build Govor.Server.slnx -c Release --no-restore
dotnet test Govor.Server.slnx -c Release --no-build --no-restore --logger trx --results-directory artifacts/coverage --collect 'XPlat Code Coverage;Format=json,cobertura'
./tests/Measure-ApplicationCoverage.ps1 -ResultsDirectory artifacts/coverage
./tests/Measure-ApplicationCoverage.ps1 -ResultsDirectory artifacts/coverage -AssemblyName Govor.API -ExcludeGeneratedSources -MinimumLineCoverage 98 -MinimumBranchCoverage 92
```
Для PostgreSQL задайте TEST_POSTGRES_CONNECTION согласно [README.md](README.md).
CI проверяет оба порога на SQLite и PostgreSQL. Объединяются попадания всех четырёх
проектов, проценты отдельных проектов не складываются. Каждый новый запуск должен
использовать свежую папку отчётов. Проверен и отрицательный сценарий: требование
100% корректно отклоняется скриптом.
Итоговые локальные TRX и JSON: `artifacts/test-results/api-final-sqlite` и
`artifacts/test-results/api-final-postgres`. Скрипт создаёт api-coverage.json и
application-coverage.json. Артефакты игнорируются Git; CI сохраняет свои отчёты.
## Границы проверки
Остаются 37 строк и 34 пути ветвления исходников API. Большинство строк находятся
в Program.cs: production startup guards, создание реального Firebase с credentials,
режим migrate-only и отдельные ошибки readiness. Остаются также защитный выход
ProfileHub при пустом наборе адресатов (текущий пользователь добавляется всегда),
часть обработки отмены worker и несколько комбинаций условий. Точные строки есть
в JSON-отчёте. Это высокое, но не стопроцентное покрытие.
Compiler/nullable и NuGet warnings остаются. Реальные Firebase credentials,
доставка push на устройство, нагрузка и production-развёртывание не проверялись.
+90
View File
@@ -0,0 +1,90 @@
# Покрытие Govor.Application
Проверка 24.10.2026, Release, .NET SDK 10.0.400. Покрытие Application увеличено
с 82,8% строк до **98,88% строк** и **93,53% ветвей**. На этапе расширения
Application добавлена 191 проверка, затем при расширении API — ещё 172.
| Проект | SQLite: пройдено | PostgreSQL 17.4: пройдено |
| --- | ---: | ---: |
| Govor.Application.Tests | 295 | 295 |
| Govor.API.Tests | 271 | 271 |
| Govor.Domain.Tests | 8 | 8 |
| Govor.Server.Tests | 136 | 136 |
| Всего | 710 | 710 |
Ошибок и пропусков нет в обоих прогонах. Release-сборка проходит; существующие
compiler/nullable warnings и предупреждения NuGet для ImageSharp остаются.
## Что проверяется
Unit-тесты проверяют JWT, пароли, username, claims, присутствие, файловое
хранилище, push dispatch и ошибки транспорта, границы форматов E2EE. Mocks
используются для внешних зависимостей и управляемых отказов.
Интеграционные тесты проверяют регистрацию и роли, профили, дружбу и блокировки,
сессии и refresh/replay, криптографические ключи, push-токены, сообщения и
прочтения, доступ к медиа, группы и аватары, реакции и наборы реакций.
Проверяются права доступа, отсутствующие данные, валидация, ошибки сохранения
и откат транзакций. Перехватчик команд БД воспроизводит отдельные отказы и гонки.
Серверные тесты дополняют проверку через HTTP и SignalR: авторизация, E2EE,
некорректные конверты и маршрутизация, лимиты устройств, вложения, Firebase
batching и классификация ошибок. Внешний Firebase transport подменён.
SQLite использует отдельную in-memory БД. PostgreSQL проверяет реальные
миграции, ограничения и поведение запросов: каждый экземпляр тестовой БД
получает уникальную схему, которая удаляется после теста. Для локального
прогона использован отдельный временный кластер на 127.0.0.1:55439 с БД
govor_validation_tests. Он не использует рабочие базы.
## Реализованные методы и исправления
- Last seen читается из БД; для неизвестного пользователя возвращается null.
- Медиа по URL ищется по точному URL в метаданных и читается из storage;
пустой URL и отсутствующие данные обрабатываются явно.
- Блокировка сохраняет инициатора как владельца блокировки. Другой участник
не может перехватить или снять её. Разблокировка переводит отношение в
Rejected: для дружбы снова требуется согласие.
- Новые криптографические сессии и одноразовые ключи явно добавляются в EF,
исправляя ошибочное UPDATE и DbUpdateConcurrencyException.
- Ротация и расходование ключей проверяют владельца сессии; чтение ключей
включает SignedPreKey.
- Чтение и удаление файлов проверяют канонический путь с границей корневой
директории, включая обход через `..` и похожее имя соседней папки.
- Пустой username возвращает ошибку валидации вместо NullReferenceException.
## Подсчёт и воспроизведение
Из корня репозитория после Release-сборки:
```powershell
dotnet test Govor.Server.slnx -c Release --no-build --no-restore --logger trx --results-directory artifacts/coverage --collect 'XPlat Code Coverage;Format=json,cobertura'
./tests/Measure-ApplicationCoverage.ps1 -ResultsDirectory artifacts/coverage
```
Для PostgreSQL задайте TEST_POSTGRES_CONNECTION согласно [README.md](README.md).
Запуски с покрытием и другие тестовые запуски не должны одновременно использовать
одни и те же выходные сборки. Для нового измерения используйте свежую папку результатов.
Скрипт объединяет попадания по строкам и ветвям Govor.Application.dll из всех
четырёх проектов, устраняет дубликаты и создаёт application-coverage.json.
Итог: 2727 из 2758 строк, 1199 из 1282 путей ветвления. Код сборки Application
не исключался из измерения. CI на SQLite и PostgreSQL требует минимум
98% строк и 92% ветвей; снижение ниже порога завершает проверку ошибкой.
Локальный итоговый отчёт:
`artifacts/test-results/api-final-sqlite/application-coverage.json`.
TRX итоговых прогонов находятся в `api-final-sqlite` и
`api-final-postgres` под `artifacts/test-results`.
## Оставшиеся ограничения
Покрытие не равно 100%: остаются 31 строка и 83 пути ветвления. Это в том числе
старые конструкторы исключений/результатов, отдельные защитные проверки E2EE,
ветви ошибок файловой системы и media processor, обработка отдельных гонок
и отказов в authentication, groups, reactions и push. Точные строки перечислены
в JSON-отчёте; показатель строк не означает полного покрытия всех условий.
Эти результаты подтверждают прохождение проверенных сценариев, но не доказывают
отсутствие всех ошибок. Нагрузочные испытания, production-развёртывание и
доставка push на физические устройства в эту проверку не входили.
@@ -1,21 +1,25 @@
<Project Sdk="Microsoft.NET.Sdk"> <Project>
<PropertyGroup> <PropertyGroup>
<TargetFramework>net10.0</TargetFramework> <TargetFramework>net10.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings> <ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable> <Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
<IsTestProject>true</IsTestProject> <IsTestProject>true</IsTestProject>
<IsPackable>false</IsPackable>
</PropertyGroup> </PropertyGroup>
<ItemGroup> <ItemGroup>
<Compile Include="$(MSBuildThisFileDirectory)Shared/TestDatabase.cs" Link="Shared/TestDatabase.cs" />
<Using Include="Govor.Tests.Shared" />
<Using Include="NUnit.Framework" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" /> <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
<PackageReference Include="NUnit" Version="4.4.0-beta.1" /> <PackageReference Include="NUnit" Version="4.3.2" />
<PackageReference Include="NUnit3TestAdapter" Version="4.6.0" /> <PackageReference Include="NUnit3TestAdapter" Version="5.0.0" />
<PackageReference Include="Moq" Version="4.20.72" /> <PackageReference Include="Moq" Version="4.20.72" />
<PackageReference Include="NUnit.Analyzers" Version="4.4.0" PrivateAssets="all" />
<PackageReference Include="coverlet.collector" Version="6.0.2" PrivateAssets="all" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.10" /> <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.10" />
<PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="3.0.3" /> <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="3.0.3" />
<PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.10" /> <Reference Include="SmartRes">
<Using Include="NUnit.Framework" /> <HintPath>$(MSBuildThisFileDirectory)../libs/SmartRes.dll</HintPath>
<ProjectReference Include="../Govor.API/Govor.API.csproj" /> </Reference>
<Reference Include="SmartRes"><HintPath>../libs/SmartRes.dll</HintPath></Reference>
</ItemGroup> </ItemGroup>
</Project> </Project>
+6
View File
@@ -0,0 +1,6 @@
global using Govor.Application.Friends;
global using Govor.Application.Infrastructure.Extensions;
global using Govor.Application.Medias;
global using Govor.Application.Storage;
global using Govor.Application.Users.UserOnlineStatus;
global using Govor.Application.PrivateUserChats;
@@ -0,0 +1,6 @@
<Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<ProjectReference Include="../../Govor.API/Govor.API.csproj" />
<PackageReference Include="AutoFixture" Version="5.0.0-preview0012" />
</ItemGroup>
</Project>
@@ -0,0 +1,165 @@
using AutoMapper;
using Govor.API.Controllers;
using Govor.API.Controllers.AdminStuff;
using Govor.API.Hubs.Infrastructure;
using Govor.Application.Groups;
using Govor.Application.Infrastructure.Extensions;
using Govor.Application.Messages;
using Govor.Application.Reactions;
using Govor.Contracts.Requests;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Govor.Tests.Shared;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Moq;
namespace Govor.API.Tests.Integration.Controllers;
[TestFixture]
public class GroupControllerBoundaryTests
{
[Test]
public async Task MembersAndInvitationsMapContractsAndRevokeUsesCurrentActor()
{
var actor = Guid.NewGuid(); var group = Guid.NewGuid(); var invitation = Guid.NewGuid();
var user = new Mock<ICurrentUserService>(); user.Setup(x => x.GetCurrentUserId()).Returns(actor);
var groups = new Mock<IGroupManagementService>(); var mapper = new Mock<IMapper>();
var members = new List<GroupMember>(); var invitations = new List<GroupInvitation>();
var memberDtos = new List<Govor.Contracts.Responses.GroupMemberResponse>();
var invitationDtos = new List<Govor.Contracts.Responses.GroupInvitationResponse>();
groups.Setup(x => x.MembersAsync(actor, group, true, 3, 7)).ReturnsAsync(members);
groups.Setup(x => x.InvitationsAsync(actor, group)).ReturnsAsync(invitations);
groups.Setup(x => x.RevokeInvitationAsync(actor, group, invitation)).ReturnsAsync(Result.Success());
mapper.Setup(x => x.Map<List<Govor.Contracts.Responses.GroupMemberResponse>>(members)).Returns(memberDtos);
mapper.Setup(x => x.Map<List<Govor.Contracts.Responses.GroupInvitationResponse>>(invitations)).Returns(invitationDtos);
var controller = new GroupsController(groups.Object, user.Object, mapper.Object, null!, Mock.Of<IMessageRemovingService>(), Mock.Of<IChatNotificationService>(), Mock.Of<IGroupAvatarService>());
Assert.That(((OkObjectResult)await controller.Members(group, true, 3, 7)).Value, Is.SameAs(memberDtos));
Assert.That(((OkObjectResult)await controller.Invitations(group)).Value, Is.SameAs(invitationDtos));
Assert.That(((StatusCodeResult)await controller.RevokeInvitation(group, invitation)).StatusCode, Is.EqualTo(204));
groups.Verify(x => x.RevokeInvitationAsync(actor, group, invitation), Times.Once);
}
[TestCase(false)]
[TestCase(true)]
public async Task RequiredChannelReadMapsSettingsAndFailuresPreventMutation(bool failure)
{
var actor = Guid.NewGuid();
var groups = new Mock<IGroupManagementService>();
var user = new Mock<ICurrentUserService>();
user.Setup(x => x.GetCurrentUserId()).Returns(actor);
var settings = new ServerCommunitySettings { RequiredChannelId = Guid.NewGuid(), AllowLeave = true };
groups.Setup(x => x.GetRequiredChannelAsync(actor)).ReturnsAsync(failure
? Result.Failure<ServerCommunitySettings>(Error.Forbidden("denied", "denied"))
: settings);
var notifier = new Mock<IChatNotificationService>(MockBehavior.Strict);
var controller = new RequiredChannelController(groups.Object, user.Object, notifier.Object);
var response = (ObjectResult)await controller.Get();
Assert.That(response.StatusCode, Is.EqualTo(failure ? 403 : 200));
if (failure)
{
Assert.That(((ObjectResult)await controller.Set(new())).StatusCode, Is.EqualTo(403));
groups.Verify(x => x.SetRequiredChannelAsync(It.IsAny<Guid>(), It.IsAny<Guid?>(), It.IsAny<bool>()),
Times.Never);
}
else
{
Assert.That(response.Value!.GetType().GetProperty("channelId")!.GetValue(response.Value),
Is.EqualTo(settings.RequiredChannelId));
}
notifier.VerifyNoOtherCalls();
}
[Test]
public async Task GroupReadsForwardQueryAndPaging()
{
using var db = new TestDatabase();
var groups = new Mock<IGroupManagementService>();
var user = new Mock<ICurrentUserService>();
user.Setup(x => x.GetCurrentUserId()).Returns(db.Alice);
var mapper = new Mock<IMapper>();
var list = new List<GroupSummary>();
var mapped = new List<Govor.Contracts.Responses.GroupResponse>();
groups.Setup(x => x.MineAsync(db.Alice, 3, 7)).ReturnsAsync(list);
groups.Setup(x => x.SearchAsync(db.Alice, "needle", 4, 8)).ReturnsAsync(list);
mapper.Setup(x => x.Map<List<Govor.Contracts.Responses.GroupResponse>>(list)).Returns(mapped);
var controller = new GroupsController(groups.Object, user.Object, mapper.Object, db.Context,
Mock.Of<IMessageRemovingService>(), Mock.Of<IChatNotificationService>(), Mock.Of<IGroupAvatarService>());
Assert.That(((OkObjectResult)await controller.Mine(3, 7)).Value, Is.SameAs(mapped));
Assert.That(((OkObjectResult)await controller.Search("needle", 4, 8)).Value, Is.SameAs(mapped));
groups.Verify(x => x.MineAsync(db.Alice, 3, 7), Times.Once);
groups.Verify(x => x.SearchAsync(db.Alice, "needle", 4, 8), Times.Once);
}
[TestCase(false)]
[TestCase(true)]
public async Task AvatarRemovalNotifiesOnlyAfterSuccess(bool failure)
{
using var db = new TestDatabase();
var user = new Mock<ICurrentUserService>();
user.Setup(x => x.GetCurrentUserId()).Returns(db.Alice);
var avatars = new Mock<IGroupAvatarService>();
avatars.Setup(x => x.RemoveAsync(db.Alice, db.ChatId))
.ReturnsAsync(failure ? Result.Failure(Error.Forbidden("denied", "denied")) : Result.Success());
var notifier = new Mock<IChatNotificationService>();
var controller = new GroupsController(Mock.Of<IGroupManagementService>(), user.Object, Mock.Of<IMapper>(),
db.Context, Mock.Of<IMessageRemovingService>(), notifier.Object, avatars.Object);
var response = await controller.RemoveAvatar(db.ChatId);
Assert.That(failure ? ((ObjectResult)response).StatusCode : ((StatusCodeResult)response).StatusCode,
Is.EqualTo(failure ? 403 : 204));
notifier.Verify(x => x.NotifyGroupProfileChangedAsync(db.ChatId), failure ? Times.Never() : Times.Once());
}
[TestCase(0)]
[TestCase(2_097_153)]
public async Task AvatarLengthRejectsBeforeService(int size)
{
var file = new Mock<IFormFile>();
file.SetupGet(x => x.Length).Returns(size);
var avatars = new Mock<IGroupAvatarService>(MockBehavior.Strict);
var controller = new GroupsController(Mock.Of<IGroupManagementService>(), Mock.Of<ICurrentUserService>(),
Mock.Of<IMapper>(), null!, Mock.Of<IMessageRemovingService>(), Mock.Of<IChatNotificationService>(),
avatars.Object);
Assert.That(await controller.UploadAvatar(Guid.NewGuid(), new() { File = file.Object }),
Is.TypeOf<BadRequestObjectResult>());
avatars.VerifyNoOtherCalls();
}
[Test]
public async Task FailedGroupMessageRemovalNeverNotifies()
{
using var db = new TestDatabase();
var message = db.AddMessage(type: RecipientType.Group);
var user = new Mock<ICurrentUserService>();
user.Setup(x => x.GetCurrentUserId()).Returns(db.Alice);
var remover = new Mock<IMessageRemovingService>();
remover.Setup(x => x.DeleteMessageAsync(It.IsAny<Govor.Application.Messages.Parameters.DeleteMessage>()))
.ReturnsAsync(Result.Failure<Message>(Error.Forbidden("denied", "denied")));
var notifier = new Mock<IChatNotificationService>(MockBehavior.Strict);
var controller = new GroupsController(Mock.Of<IGroupManagementService>(), user.Object, Mock.Of<IMapper>(),
db.Context, remover.Object, notifier.Object, Mock.Of<IGroupAvatarService>());
Assert.That(((ObjectResult)await controller.RemoveMessage(db.ChatId, message.Id)).StatusCode, Is.EqualTo(403));
notifier.VerifyNoOtherCalls();
}
[Test]
public async Task ChannelReactionReadMapsPolicy()
{
var actor = Guid.NewGuid();
var group = Guid.NewGuid();
var user = new Mock<ICurrentUserService>();
user.Setup(x => x.GetCurrentUserId()).Returns(actor);
var service = new Mock<IMessageReactionService>();
var policy = new ChannelReactionPolicy(group, Govor.Domain.Models.Reactions.ChannelReactionMode.All, 2, []);
service.Setup(x => x.GetPolicyAsync(actor, group)).ReturnsAsync(policy);
var mapper = new Mock<IMapper>();
var dto = new Govor.Contracts.Responses.SignalR.ChannelReactionPolicyResponse();
mapper.Setup(x => x.Map<Govor.Contracts.Responses.SignalR.ChannelReactionPolicyResponse>(policy)).Returns(dto);
var controller = new ChannelReactionsController(service.Object, user.Object, mapper.Object,
Mock.Of<IChatNotificationService>());
Assert.That(((OkObjectResult)await controller.Get(group)).Value, Is.SameAs(dto));
}
}
@@ -0,0 +1,89 @@
using Govor.API.Common.Extensions;
using Govor.API.Common.Mapping;
using Govor.API.Filters;
using Govor.Application.Profiles;
using Govor.Application.Users.UserOnlineStatus;
using Govor.Contracts.DTOs;
using Govor.Contracts.Responses.SignalR;
using Govor.Domain.Common;
using Govor.Domain.Models.Users;
using Govor.Tests.Shared;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using System.Security.Claims;
namespace Govor.API.Tests.Integration.Filters;
[TestFixture]
public class HubExceptionFilterTests
{
public sealed class TestHub : Hub
{
public Task<HubResult<int>> Typed() => Task.FromResult(HubResult<int>.Ok(7));
public Task Plain() => Task.CompletedTask;
public int Synchronous() => 7;
}
[TestCase(0, HubResultStatus.BadRequest)]
[TestCase(1, HubResultStatus.Unauthorized)]
[TestCase(2, HubResultStatus.NotFound)]
[TestCase(3, HubResultStatus.Conflict)]
[TestCase(4, HubResultStatus.ServerError)]
public async Task ActiveSessionExceptionsAreMappedWithoutLeakingServerErrors(int kind, HubResultStatus expected)
{
using var db = new TestDatabase();
var sid = Guid.NewGuid();
db.Context.UserSessions.Add(new()
{
Id = sid, UserId = db.Alice, DeviceInfo = "test", RefreshTokenHash = "hash", CreatedAt = DateTime.UtcNow,
ExpiresAt = DateTime.UtcNow.AddDays(1)
});
db.Context.SaveChanges();
var caller = new Mock<HubCallerContext>();
caller.SetupGet(x => x.User).Returns(new ClaimsPrincipal(new ClaimsIdentity(
new[] { new Claim("userId", db.Alice.ToString()), new Claim("sid", sid.ToString()) }, "test")));
using var hub = new TestHub();
var invocation = new HubInvocationContext(caller.Object, Mock.Of<IServiceProvider>(), hub,
typeof(TestHub).GetMethod(nameof(TestHub.Typed))!, []);
Exception error = kind switch
{
0 => new ArgumentException("invalid"), 1 => new UnauthorizedAccessException("denied"),
2 => new KeyNotFoundException("missing"), 3 => new InvalidOperationException("conflict"),
_ => new Exception("private detail")
};
var result =
(HubResult<int>)(await new HubExceptionFilter(NullLogger<HubExceptionFilter>.Instance, db.Context)
.InvokeMethodAsync(invocation, _ => throw error))!;
Assert.That(result.Status, Is.EqualTo(expected));
if (kind == 4) Assert.That(result.ErrorMessage, Is.EqualTo("Internal server error"));
caller.Verify(x => x.Abort(), Times.Never);
}
[TestCase(nameof(TestHub.Typed))]
[TestCase(nameof(TestHub.Plain))]
[TestCase(nameof(TestHub.Synchronous))]
public async Task MissingSessionAbortsAndHandlesReturnShapes(string method)
{
using var db = new TestDatabase();
using var hub = new TestHub();
var caller = new Mock<HubCallerContext>();
caller.SetupGet(x => x.User).Returns(new ClaimsPrincipal());
var invocation = new HubInvocationContext(caller.Object, Mock.Of<IServiceProvider>(), hub,
typeof(TestHub).GetMethod(method)!, []);
var invoked = false;
var result =
await new HubExceptionFilter(NullLogger<HubExceptionFilter>.Instance, db.Context).InvokeMethodAsync(
invocation, _ =>
{
invoked = true;
return ValueTask.FromResult<object?>(7);
});
Assert.That(invoked, Is.False);
caller.Verify(x => x.Abort(), Times.Once);
if (method == nameof(TestHub.Typed))
Assert.That(((HubResult<int>)result!).Status, Is.EqualTo(HubResultStatus.Unauthorized));
else Assert.That(result, Is.Null);
}
}
@@ -0,0 +1,35 @@
using Govor.API.Hubs.Infrastructure;
using Govor.Application.Infrastructure.Common;
using Govor.Tests.Shared;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.API.Tests.Integration.Notifications;
[TestFixture]
public class ChatPushWorkerTests
{
private sealed class Worker(IServiceScopeFactory factory):ChatPushWorker(factory,NullLogger<ChatPushWorker>.Instance)
{
public Task Run(CancellationToken token)=>ExecuteAsync(token);
}
[TestCase(0)] [TestCase(1)] [TestCase(2)] [TestCase(3)]
public async Task WorkerDisposesScopesAndStopsOnCancellationIncludingFailurePaths(int mode)
{
using var db=new TestDatabase();using var cancellation=new CancellationTokenSource();
var factory=new Mock<IServiceScopeFactory>();var scope=new Mock<IServiceScope>();var provider=new Mock<IServiceProvider>();
var clock=new Mock<INowDateTimeProvider>();clock.SetupGet(x=>x.Now).Returns(DateTime.UtcNow);
var dispatcher=new ChatPushDispatcher(db.Context,Mock.Of<IChatNotificationService>(),clock.Object);
scope.SetupGet(x=>x.ServiceProvider).Returns(provider.Object);provider.Setup(x=>x.GetService(typeof(ChatPushDispatcher))).Returns(dispatcher);
scope.Setup(x=>x.Dispose()).Callback(()=>cancellation.Cancel());
if(mode==0) cancellation.Cancel();
if(mode is 1 or 2) factory.Setup(x=>x.CreateScope()).Returns(()=>{cancellation.Cancel();throw mode==1?new OperationCanceledException(cancellation.Token):new InvalidOperationException("scope failure");});
else factory.Setup(x=>x.CreateScope()).Returns(scope.Object);
using var worker=new Worker(factory.Object);
await worker.Run(cancellation.Token).WaitAsync(TimeSpan.FromSeconds(5));
factory.Verify(x=>x.CreateScope(),mode==0?Times.Never():Times.Once());
scope.Verify(x=>x.Dispose(),mode==3?Times.Once():Times.Never());
}
}
@@ -0,0 +1,93 @@
using Govor.API.Hubs;
using Govor.API.Hubs.Infrastructure;
using Govor.Application.PrivateUserChats;
using Govor.Application.Profiles;
using Govor.Application.PushNotifications;
using Govor.Contracts.Responses.SignalR;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Govor.Tests.Shared;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using Govor.Application.Infrastructure.Common;
using Microsoft.EntityFrameworkCore;
namespace Govor.API.Tests.Integration.Notifications;
[TestFixture]
public class NotificationBoundaryTests
{
[TestCase(true)]
[TestCase(false)]
public async Task MissingChatIsAcknowledgedButTemporaryLookupFailureRequiresRetry(bool missing)
{
using var db = new TestDatabase();
var chats = new Mock<IUserPrivateChatsGetterService>();
chats.Setup(x => x.GetPrivateChatAsync(db.ChatId)).ReturnsAsync(Result.Failure<PrivateChat>(
missing ? Error.NotFound("missing", "missing") : Error.ServerError("database", "unavailable")));
var push = new Mock<IPushNotificationService>(MockBehavior.Strict);
var notifier = new ChatNotificationService(Mock.Of<IHubContext<ChatsHub>>(), push.Object, chats.Object,
Mock.Of<IProfileService>(), db.Context, NullLogger<ChatNotificationService>.Instance);
Assert.That(await notifier.DeliverPushAsync(new() { RecipientId = db.ChatId, RecipientType = RecipientType.User }), Is.EqualTo(missing));
push.VerifyNoOtherCalls();
}
[Test]
public async Task CancellationDuringPushLeavesClaimForLaterRetry()
{
using var db = new TestDatabase();
using var cancellation = new CancellationTokenSource();
var message = db.AddMessage();
var now = DateTime.UtcNow;
db.Context.ChatPushNotifications.Add(new() { MessageId = message.Id, NextAttemptAt = now.AddMinutes(-1) });
await db.Context.SaveChangesAsync();
var notifier = new Mock<IChatNotificationService>();
notifier.Setup(x => x.DeliverPushAsync(It.IsAny<UserMessageResponse>())).Returns(() =>
{
cancellation.Cancel();
throw new OperationCanceledException(cancellation.Token);
});
var clock = new Mock<INowDateTimeProvider>();
clock.SetupGet(x => x.Now).Returns(now);
var dispatcher = new ChatPushDispatcher(db.Context, notifier.Object, clock.Object);
Assert.ThrowsAsync<OperationCanceledException>(() => dispatcher.DispatchAsync(cancellation.Token));
var pending = await db.Context.ChatPushNotifications.AsNoTracking().SingleAsync();
Assert.That(pending.Attempts, Is.EqualTo(1));
Assert.That(pending.NextAttemptAt, Is.GreaterThan(now));
}
[TestCase(0)] [TestCase(1)] [TestCase(2)] [TestCase(3)] [TestCase(4)]
public async Task PushHandlesNoRecipientsReadersMissingProfileAndProviderFailures(int mode)
{
using var db=new TestDatabase();var message=db.AddMessage();
if(mode==1){db.Context.MessageViews.Add(new(){Id=Guid.NewGuid(),MessageId=message.Id,UserId=db.Bob,ViewedAt=DateTime.UtcNow});db.Context.SaveChanges();}
var chats=new Mock<IUserPrivateChatsGetterService>();chats.Setup(x=>x.GetPrivateChatAsync(db.ChatId)).ReturnsAsync(mode==0?new PrivateChat{UserAId=db.Alice,UserBId=db.Alice}:new PrivateChat{UserAId=db.Alice,UserBId=db.Bob});
var profiles=new Mock<IProfileService>();profiles.Setup(x=>x.GetUserProfileAsync(db.Alice)).ReturnsAsync(Result.Failure<UserProfile>(Error.NotFound("missing","missing")));
var push=new Mock<IPushNotificationService>();
if(mode==4) push.Setup(x=>x.SendToUsersAsync(It.IsAny<IEnumerable<Guid>>(),It.IsAny<string>(),It.IsAny<string>(),It.IsAny<string>(),It.IsAny<string>(),It.IsAny<Dictionary<string,string>?>())).ThrowsAsync(new Exception("transport"));
else push.Setup(x=>x.SendToUsersAsync(It.IsAny<IEnumerable<Guid>>(),It.IsAny<string>(),It.IsAny<string>(),It.IsAny<string>(),It.IsAny<string>(),It.IsAny<Dictionary<string,string>?>())).ReturnsAsync(mode==3?Result.Failure(Error.ServerError("push","failure")):Result.Success());
var notifier=new ChatNotificationService(Mock.Of<IHubContext<ChatsHub>>(),push.Object,chats.Object,profiles.Object,db.Context,NullLogger<ChatNotificationService>.Instance);
var result=await notifier.DeliverPushAsync(new(){MessageId=message.Id,SenderId=db.Alice,RecipientId=db.ChatId,RecipientType=RecipientType.User});
Assert.That(result,Is.EqualTo(mode<3));
if(mode<2){push.VerifyNoOtherCalls();profiles.VerifyNoOtherCalls();}
else push.Verify(x=>x.SendToUsersAsync(It.Is<IEnumerable<Guid>>(ids=>ids.SequenceEqual(new[]{db.Bob})),"Govor","New message","chat_messages",$"chat_{db.ChatId}",It.IsAny<Dictionary<string,string>?>()),Times.Once);
}
[Test]
public async Task LegacyReadAndRemovalEventsReachActiveSessionAndMissingChatIsIgnored()
{
using var db=new TestDatabase();var sid=Guid.NewGuid();db.Context.UserSessions.Add(new(){Id=sid,UserId=db.Alice,ExpiresAt=DateTime.UtcNow.AddDays(1)});db.Context.SaveChanges();
var proxy=new Mock<IClientProxy>();var clients=new Mock<IHubClients>();clients.Setup(x=>x.Groups(It.IsAny<IReadOnlyList<string>>())).Returns(proxy.Object);
var hub=new Mock<IHubContext<ChatsHub>>();hub.SetupGet(x=>x.Clients).Returns(clients.Object);
var chats=new Mock<IUserPrivateChatsGetterService>();chats.Setup(x=>x.GetPrivateChatAsync(db.ChatId)).ReturnsAsync(new PrivateChat{UserAId=db.Alice,UserBId=db.Bob});
var notifier=new ChatNotificationService(hub.Object,Mock.Of<IPushNotificationService>(),chats.Object,Mock.Of<IProfileService>(),db.Context,NullLogger<ChatNotificationService>.Instance);
await notifier.NotifyMessageWasReadAsync(new(){ViewId=Guid.NewGuid(),MessageId=Guid.NewGuid(),ReaderId=db.Alice,WhenWas=DateTime.UtcNow,RecipientId=db.ChatId,RecipientType=RecipientType.User});
await notifier.NotifyMessageRemovedAsync(new(){MessageId=Guid.NewGuid(),SenderId=db.Alice,RecipientId=db.ChatId,RecipientType=RecipientType.User});
await notifier.NotifyMessageEditedAsync(new(){MessageId=Guid.NewGuid(),EditorId=db.Alice,RecipientId=db.ChatId,RecipientType=RecipientType.User});
foreach(var method in new[]{"MessageReaded","MessageRead","MessageRemoved","MessageEdited"})proxy.Verify(x=>x.SendCoreAsync(method,It.IsAny<object?[]>(),default),Times.Once);
chats.Setup(x=>x.GetPrivateChatAsync(db.ChatId)).ReturnsAsync(Result.Failure<PrivateChat>(Error.NotFound("missing","missing")));
proxy.Invocations.Clear();await notifier.NotifyChatReadAsync(new(){ChatId=db.ChatId,RecipientType=RecipientType.User});proxy.VerifyNoOtherCalls();
}
}
@@ -0,0 +1,38 @@
using Govor.API.Common.Extensions;
using Govor.Application.PushNotifications;
using Govor.Application.PushNotifications.Providers;
using Govor.Application.Storage;
using Govor.Domain;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Moq;
namespace Govor.API.Tests.Unit.Common;
[TestFixture]
public class ConfigurationTests
{
[TestCase(false)] [TestCase(true)]
public void DatabaseConfigurationUsesPostgresAndHonorsDetailedErrors(bool detailed)
{
var config=new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string,string?>{{"ConnectionStrings:GovorDbContext","Host=localhost;Database=configuration_tests;Username=tests"},{"Database:EnableDetailedErrors",detailed.ToString()}}).Build();
var services=new ServiceCollection();services.AddGovorDbContext(config);
using var provider=services.BuildServiceProvider();using var scope=provider.CreateScope();var db=scope.ServiceProvider.GetRequiredService<GovorDbContext>();
Assert.That(db.Database.ProviderName,Is.EqualTo("Npgsql.EntityFrameworkCore.PostgreSQL"));
Assert.That(db.Database.CreateExecutionStrategy().RetriesOnFailure,Is.True);
var options=scope.ServiceProvider.GetRequiredService<DbContextOptions<GovorDbContext>>();
Assert.That(options.FindExtension<Microsoft.EntityFrameworkCore.Infrastructure.CoreOptionsExtension>()!.DetailedErrorsEnabled,Is.EqualTo(detailed));
}
[Test]
public void DisabledFirebaseAndLocalStorageResolveThroughProductionRegistration()
{
var services=new ServiceCollection();services.AddLogging();
services.AddSingleton<IConfiguration>(new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string,string?>{{"Firebase:Enabled","false"}}).Build());
var environment=new Mock<IWebHostEnvironment>();environment.SetupGet(x=>x.ContentRootPath).Returns(Path.GetTempPath());services.AddSingleton(environment.Object);
services.AddServices();using var provider=services.BuildServiceProvider();using var scope=provider.CreateScope();
Assert.That(scope.ServiceProvider.GetRequiredService<IStorageService>(),Is.TypeOf<LocalStorageService>());
Assert.That(scope.ServiceProvider.GetRequiredService<IPushNotificationProvider>(),Is.TypeOf<NullPushProvider>());
}
}
@@ -0,0 +1,65 @@
using Govor.API.Common.Extensions;
using Govor.API.Common.Mapping;
using Govor.API.Filters;
using Govor.Application.Profiles;
using Govor.Application.Users.UserOnlineStatus;
using Govor.Contracts.DTOs;
using Govor.Contracts.Responses.SignalR;
using Govor.Domain.Common;
using Govor.Domain.Models.Users;
using Govor.Tests.Shared;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using System.Security.Claims;
namespace Govor.API.Tests.Unit.Common;
[TestFixture]
public class ErrorAndMappingTests
{
[TestCase(ErrorType.NotFound, 404, "Not Found")]
[TestCase(ErrorType.Validation, 400, "Validation Error")]
[TestCase(ErrorType.Conflict, 409, "Conflict")]
[TestCase(ErrorType.Unauthorized, 401, "Unauthorized")]
[TestCase(ErrorType.Forbidden, 403, "Forbidden")]
[TestCase(ErrorType.ServerError, 500, "Internal Server Error")]
[TestCase(ErrorType.Failure, 400, "Bad Request")]
public void ResultErrorsPreserveCodeDetailsAndFieldErrors(ErrorType type, int status, string title)
{
var fields = new Dictionary<string, string[]> { { "field", ["required"] } };
var error = new Error("code", "detail", type, fields);
var response = (ObjectResult)Result.Failure<int>(error).ToActionResult();
var problem = (ProblemDetails)response.Value!;
Assert.Multiple(() =>
{
Assert.That(response.StatusCode, Is.EqualTo(status));
Assert.That(problem.Title, Is.EqualTo(title));
Assert.That(problem.Detail, Is.EqualTo("detail"));
Assert.That(problem.Extensions["errorCode"], Is.EqualTo("code"));
Assert.That(problem.Extensions["errors"], Is.SameAs(fields));
});
var hub = error.ToHubResult<int>();
Assert.That((int)hub.Status, Is.EqualTo(status));
Assert.That(hub.ErrorMessage, Is.EqualTo(type == ErrorType.ServerError ? "Internal server error." : "detail"));
}
[TestCase(false)]
[TestCase(true)]
public void MappingActionsUseCurrentOnlineState(bool online)
{
var id = Guid.NewGuid();
var store = new Mock<IOnlineUserStore>();
store.Setup(x => x.IsOnline(id)).Returns(online);
var user = new UserDto();
new UserToUserDtoMappingAction(store.Object).Process(new User { Id = id }, user, null!);
var profile = new UserProfileDto();
new UserProfileToUserProfileDtoMappingAction(store.Object).Process(new UserProfile { Id = id }, profile, null!);
Assert.That(user.IsOnline, Is.EqualTo(online));
Assert.That(profile.IsOnline, Is.EqualTo(online));
store.Verify(x => x.IsOnline(id), Times.Exactly(2));
}
}
@@ -0,0 +1,135 @@
using Govor.API.Controllers.AdminStuff;
using Govor.Application.Infrastructure.AdminsStuff;
using Govor.Contracts.Requests;
using Govor.Contracts.DTOs;
using Govor.Contracts.Responses.Admins;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.API.Tests.Unit.Controllers;
[TestFixture]
public class AdministrationControllerTests
{
private Mock<IInvitationGenerator> _generator = null!;
private Mock<IInvitationGetter> _getter = null!;
private InviteUserController _invites = null!;
private readonly DateTime _end = new(2030, 1, 1, 0, 0, 0, DateTimeKind.Utc);
[TearDown]
public void TearDown() => _invites.Dispose();
[SetUp]
public void Setup()
{
_generator = new(); _getter = new();
_invites = Create("admin-secret");
}
private InviteUserController Create(string? key) => new(_generator.Object, _getter.Object,
new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string, string?> { ["InvitationAdmin:Key"] = key }).Build(),
NullLogger<InviteUserController>.Instance);
[TestCase(false)]
[TestCase(true)]
public async Task InvitationForwardsAllFields(bool withKey)
{
_generator.Setup(g => g.GenerateInvitationCode(_end, 12, true, "description")).ReturnsAsync("code");
var response = withKey
? await _invites.InvitationWithKey(new() { AdminKey = "admin-secret", EndDate = _end, MaxParticipants = 12, IsAdmin = true, Description = "description" })
: await _invites.Invitation(new() { EndDate = _end, MaxParticipants = 12, IsAdmin = true, Description = "description" });
Assert.That(((OkObjectResult)response).Value, Is.EqualTo("code"));
_generator.Verify(g => g.GenerateInvitationCode(_end, 12, true, "description"), Times.Once);
}
[TestCase(null, "admin-secret", 503)]
[TestCase(" ", "admin-secret", 503)]
[TestCase("admin-secret", "", 401)]
[TestCase("admin-secret", "ADMIN-SECRET", 401)]
public async Task InvalidAdminKeyNeverGeneratesInvitation(string? configured, string supplied, int status)
{
var result = (ObjectResult)await Create(configured).InvitationWithKey(new() { AdminKey = supplied });
Assert.That(result.StatusCode, Is.EqualTo(status));
_generator.VerifyNoOtherCalls();
}
[TestCase(false)]
[TestCase(true)]
public async Task GeneratorExceptionProducesBadRequest(bool withKey)
{
_generator.Setup(g => g.GenerateInvitationCode(It.IsAny<DateTime>(), It.IsAny<int>(), It.IsAny<bool>(), It.IsAny<string>())).ThrowsAsync(new InvalidOperationException("failure"));
var result = withKey ? await _invites.InvitationWithKey(new() { AdminKey = "admin-secret" }) : await _invites.Invitation(new());
Assert.That(result, Is.TypeOf<BadRequestObjectResult>());
}
[TestCase(false)]
[TestCase(true)]
public async Task InvitationListsMapFieldsAndFilterActive(bool activeOnly)
{
var active = new Invitation { Id = Guid.NewGuid(), Code = "code", Description = "desc", IsAdmin = true, MaxParticipants = 7, DateCreated = _end.AddDays(-1), EndDate = _end, Users = [new User()] };
var inactive = new Invitation { Id = Guid.NewGuid(), IsActive = false };
_getter.Setup(g => g.GetAllAsync()).ReturnsAsync([active, inactive]);
var result = activeOnly ? await _invites.GetAllActiveInvitations() : await _invites.GetAllInvitations();
var dtos = (List<InvitationResponses>)((OkObjectResult)result).Value!;
Assert.That(dtos, Has.Count.EqualTo(activeOnly ? 1 : 2));
var dto = dtos.Single(x => x.Id == active.Id);
Assert.Multiple(() => {
Assert.That(dto.Code, Is.EqualTo(active.Code)); Assert.That(dto.Description, Is.EqualTo(active.Description));
Assert.That(dto.ParticipantCount, Is.EqualTo(1)); Assert.That(dto.IsAdmin, Is.True);
Assert.That(dto.MaxParticipants, Is.EqualTo(7)); Assert.That(dto.CreatedAt, Is.EqualTo(active.DateCreated)); Assert.That(dto.EndAt, Is.EqualTo(_end));
});
_getter.Setup(g => g.FindByIdAsync(active.Id)).ReturnsAsync(active);
Assert.That(((InvitationResponses)((OkObjectResult)await _invites.GetInvitationById(active.Id)).Value!).Id, Is.EqualTo(active.Id));
}
[TestCase(0)] [TestCase(1)] [TestCase(2)]
public async Task InvitationReadExceptionsProduceBadRequest(int operation)
{
_getter.Setup(g => g.GetAllAsync()).ThrowsAsync(new Exception("failure"));
_getter.Setup(g => g.FindByIdAsync(It.IsAny<Guid>())).ThrowsAsync(new Exception("failure"));
var result = operation switch { 0 => await _invites.GetAllInvitations(), 1 => await _invites.GetAllActiveInvitations(), _ => await _invites.GetInvitationById(Guid.NewGuid()) };
Assert.That(result, Is.TypeOf<BadRequestObjectResult>());
}
[Test]
public async Task MissingInvitationReturnsNotFound()
{
_getter.Setup(g => g.FindByIdAsync(It.IsAny<Guid>())).ReturnsAsync(Result.Failure<Invitation>(Error.NotFound("missing", "missing")));
Assert.That(await _invites.GetInvitationById(Guid.NewGuid()), Is.TypeOf<NotFoundObjectResult>());
}
[Test]
public async Task UserDtosHandleMissingAndAdminInvitations()
{
var users = new Mock<IUsersAdministration>();
var a = new User { Id = Guid.NewGuid(), Username = "a", Description = "desc", Invite = new Invitation { IsAdmin = true } };
var b = new User { Id = Guid.NewGuid(), Username = "b" };
users.Setup(u => u.GetAllUsersAsync()).ReturnsAsync([a,b]);
users.Setup(u => u.GetUserById(a.Id)).ReturnsAsync(a);
var controller = new UsersController(NullLogger<UsersController>.Instance, users.Object);
var dtos = (List<UserResponse>)((OkObjectResult)await controller.AllUsers()).Value!;
Assert.That(dtos.Select(x => x.IsAdmin), Is.EqualTo(new[] { true, false }));
Assert.That(((UserResponse)((OkObjectResult)await controller.GetUserById(a.Id)).Value!).Username, Is.EqualTo("a"));
Assert.That(await controller.GetUserById(b.Id), Is.TypeOf<NotFoundResult>());
Assert.That(await controller.SetNewPassword(b.Id, new() { Password = "password" }), Is.TypeOf<NotFoundResult>());
Assert.That(await controller.SetNewPassword(a.Id, new() { Password = "password" }), Is.TypeOf<NoContentResult>());
users.Verify(u => u.SetPasswordAsync(a.Id, "password"), Times.Once);
users.Verify(u => u.SetPasswordAsync(b.Id, It.IsAny<string>()), Times.Never);
}
[TestCase(0)] [TestCase(1)] [TestCase(2)]
public async Task UserAdministrationErrorsReturn500(int operation)
{
var users = new Mock<IUsersAdministration>();
users.Setup(u => u.GetAllUsersAsync()).ThrowsAsync(new Exception("failure"));
users.Setup(u => u.GetUserById(It.IsAny<Guid>())).ThrowsAsync(new Exception("failure"));
var controller = new UsersController(NullLogger<UsersController>.Instance, users.Object);
var result = operation switch { 0 => await controller.AllUsers(), 1 => await controller.GetUserById(Guid.NewGuid()), _ => await controller.SetNewPassword(Guid.NewGuid(), new() { Password = "password" }) };
Assert.That(((ObjectResult)result).StatusCode, Is.EqualTo(500));
}
}
@@ -0,0 +1,136 @@
using Govor.API.Controllers.Authentication;
using Govor.API.Hubs.Infrastructure;
using Govor.Application.Authentication;
using Govor.Application.Users.UserSessions;
using Govor.Contracts.Requests;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.API.Tests.Unit.Controllers;
[TestFixture]
public class AuthControllerTests
{
private Mock<IAccountService> _accounts = null!;
private Mock<IInvitesService> _invites = null!;
private Mock<IUserSessionOpener> _sessions = null!;
private Mock<IChatNotificationService> _notifier = null!;
private AuthController _controller = null!;
private readonly User _user = new() { Id = Guid.NewGuid(), Username = "Иван" };
private readonly Invitation _invite = new() { Id = Guid.NewGuid(), Code = "test" };
private readonly RefreshResult _tokens = new("refresh", "access");
[SetUp]
public void SetUp()
{
_accounts = new Mock<IAccountService>();
_invites = new Mock<IInvitesService>();
_sessions = new Mock<IUserSessionOpener>();
_notifier = new Mock<IChatNotificationService>();
_controller = new(_accounts.Object, _invites.Object, _sessions.Object,
NullLogger<AuthController>.Instance, _notifier.Object);
_invites.Setup(i => i.ValidateAsync("test")).ReturnsAsync(_invite);
_accounts.Setup(a => a.RegistrationAsync("Иван", "secret", _invite)).ReturnsAsync(_user);
_accounts.Setup(a => a.LoginAsync("Иван", "secret")).ReturnsAsync(_user);
_sessions.Setup(s => s.OpenSessionAsync(_user, "phone")).ReturnsAsync(_tokens);
}
[Test]
public async Task RegistrationValidatesInvitationCreatesAccountNotifiesGroupsThenOpensSession()
{
var order = new List<string>();
_notifier.Setup(n => n.NotifyUserJoinedGroupsAsync(_user.Id)).Callback(() => order.Add("notify")).Returns(Task.CompletedTask);
_sessions.Setup(s => s.OpenSessionAsync(_user, "phone")).Callback(() => order.Add("session")).ReturnsAsync(_tokens);
var response = await _controller.Register(new RegistrationRequest { Name = "Иван", Password = "secret", InviteLink = "test", DeviceInfo = "phone" });
Assert.That(((OkObjectResult)response).Value, Is.EqualTo(_tokens));
Assert.That(order, Is.EqualTo(new[] { "notify", "session" }));
_invites.Verify(i => i.ValidateAsync("test"), Times.Once);
_accounts.Verify(a => a.RegistrationAsync("Иван", "secret", _invite), Times.Once);
}
[Test]
public async Task InvalidInvitationStopsRegistrationPipeline()
{
_invites.Setup(i => i.ValidateAsync("test")).ReturnsAsync(Result.Failure<Invitation>(Error.Validation("Invite.Invalid", "invalid")));
var response = (ObjectResult)await _controller.Register(new RegistrationRequest { Name = "Иван", Password = "secret", InviteLink = "test" });
Assert.That(response.StatusCode, Is.EqualTo(400));
Assert.That(((ProblemDetails)response.Value!).Extensions["errorCode"], Is.EqualTo("Invite.Invalid"));
_accounts.VerifyNoOtherCalls();
_sessions.VerifyNoOtherCalls();
_notifier.VerifyNoOtherCalls();
}
[TestCase(ErrorType.Conflict, 409)]
[TestCase(ErrorType.Validation, 400)]
public async Task RegistrationFailureDoesNotNotifyOrOpenSession(ErrorType type, int status)
{
_accounts.Setup(a => a.RegistrationAsync("Иван", "secret", _invite))
.ReturnsAsync(Result.Failure<User>(new Error("Auth.Failed", "failure", type)));
var response = (ObjectResult)await _controller.Register(new RegistrationRequest { Name = "Иван", Password = "secret", InviteLink = "test" });
Assert.That(response.StatusCode, Is.EqualTo(status));
_sessions.VerifyNoOtherCalls();
_notifier.VerifyNoOtherCalls();
}
[Test]
public async Task LoginReturnsTokensForTheRequestedDevice()
{
var response = (OkObjectResult)await _controller.Login(new LoginRequest { Name = "Иван", Password = "secret", DeviceInfo = "phone" });
Assert.That(response.Value, Is.EqualTo(_tokens));
_sessions.Verify(s => s.OpenSessionAsync(_user, "phone"), Times.Once);
_invites.VerifyNoOtherCalls();
_notifier.VerifyNoOtherCalls();
}
[TestCase(ErrorType.NotFound, 404)]
[TestCase(ErrorType.Failure, 400)]
[TestCase(ErrorType.Unauthorized, 401)]
public async Task FailedLoginDoesNotOpenSession(ErrorType type, int status)
{
_accounts.Setup(a => a.LoginAsync("Иван", "secret")).ReturnsAsync(Result.Failure<User>(new Error("Auth.Failed", "failure", type)));
var response = (ObjectResult)await _controller.Login(new LoginRequest { Name = "Иван", Password = "secret", DeviceInfo = "phone" });
Assert.That(response.StatusCode, Is.EqualTo(status));
_sessions.VerifyNoOtherCalls();
}
[Test]
public async Task SessionFailureIsReturnedToClient()
{
_sessions.Setup(s => s.OpenSessionAsync(_user, "phone"))
.ReturnsAsync(Result.Failure<RefreshResult>(Error.ServerError("Session.Failed", "failure")));
Assert.That(((ObjectResult)await _controller.Login(new LoginRequest { Name = "Иван", Password = "secret", DeviceInfo = "phone" })).StatusCode, Is.EqualTo(500));
}
}
[TestFixture]
public class RefreshControllerTests
{
[Test]
public async Task SuccessfulRefreshReturnsCurrentTokenContract()
{
var service = new Mock<IUserSessionRefresher>();
var tokens = new RefreshResult("new-refresh", "new-access");
service.Setup(s => s.RefreshTokenAsync("old")).ReturnsAsync(tokens);
var controller = new RefreshController(NullLogger<RefreshController>.Instance, service.Object);
var response = (OkObjectResult)await controller.Refresh(new RefreshTokenRequest { RefreshToken = "old" });
Assert.That(response.Value, Is.SameAs(tokens));
}
[TestCase(ErrorType.Failure, 400)]
[TestCase(ErrorType.Unauthorized, 401)]
[TestCase(ErrorType.ServerError, 500)]
public async Task RefreshFailureMapsToProblemDetails(ErrorType type, int status)
{
var service = new Mock<IUserSessionRefresher>();
service.Setup(s => s.RefreshTokenAsync("invalid"))
.ReturnsAsync(Result.Failure<RefreshResult>(new Error("Auth.InvalidToken", "invalid", type)));
var controller = new RefreshController(NullLogger<RefreshController>.Instance, service.Object);
var response = (ObjectResult)await controller.Refresh(new RefreshTokenRequest { RefreshToken = "invalid" });
Assert.That(response.StatusCode, Is.EqualTo(status));
Assert.That(((ProblemDetails)response.Value!).Extensions["errorCode"], Is.EqualTo("Auth.InvalidToken"));
}
}
@@ -0,0 +1,81 @@
using AutoMapper;
using Govor.API.Controllers;
using Govor.Application.Messages;
using Govor.Contracts.Requests;
using Govor.Contracts.Responses;
using Govor.Domain.Common;
using Govor.Domain.Models.Messages;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.API.Tests.Unit.Controllers;
[TestFixture]
public class ChatLoadControllerTests
{
private Mock<IMessagesLoader> _loader = null!;
private Mock<IMapper> _mapper = null!;
private ChatLoadController _controller = null!;
private readonly Guid _user = Guid.NewGuid(), _chat = Guid.NewGuid();
[SetUp]
public void SetUp()
{
_loader = new Mock<IMessagesLoader>();
_mapper = new Mock<IMapper>();
var current = new Mock<ICurrentUserService>();
current.Setup(c => c.GetCurrentUserId()).Returns(_user);
_controller = new(NullLogger<ChatLoadController>.Instance, _loader.Object, current.Object, _mapper.Object);
}
private Task<IActionResult> Load(bool group, MessageQuery query) =>
group ? _controller.GetGroupMessages(_chat, query) : _controller.GetUserMessages(_chat, query);
[TestCase(false)]
[TestCase(true)]
public async Task SuccessfulPageIsMappedAndReturnsOk(bool group)
{
var messages = new List<Message> { new() { Id = Guid.NewGuid() } };
var response = new List<MessageResponse>();
_mapper.Setup(m => m.Map<List<MessageResponse>>(messages)).Returns(response);
_loader.Setup(l => l.LoadMessagesInChatGroup(_chat, _user, null, 20, 2)).ReturnsAsync(messages);
_loader.Setup(l => l.LoadMessagesInUserChat(_chat, _user, null, 20, 2)).ReturnsAsync(messages);
Assert.That(((OkObjectResult)await Load(group, new MessageQuery { Before = 20, After = 2 })).Value, Is.SameAs(response));
}
[TestCase(false, -1, 0)]
[TestCase(true, 0, -1)]
[TestCase(false, 101, 0)]
[TestCase(true, 0, 101)]
[TestCase(false, 60, 41)]
[TestCase(true, 60, 41)]
public async Task InvalidPageLimitsDoNotCallLoader(bool group, int before, int after)
{
Assert.That(await Load(group, new MessageQuery { Before = before, After = after }), Is.TypeOf<BadRequestObjectResult>());
_loader.VerifyNoOtherCalls();
}
[TestCase(false, ErrorType.Forbidden, 403)]
[TestCase(true, ErrorType.Forbidden, 403)]
[TestCase(false, ErrorType.NotFound, 404)]
[TestCase(true, ErrorType.Validation, 400)]
public async Task ServiceFailureReturnsProblemDetails(bool group, ErrorType type, int status)
{
var failure = Result.Failure<List<Message>>(new Error("Chat.Failed", "failure", type));
_loader.Setup(l => l.LoadMessagesInChatGroup(_chat, _user, null, 20, 2)).ReturnsAsync(failure);
_loader.Setup(l => l.LoadMessagesInUserChat(_chat, _user, null, 20, 2)).ReturnsAsync(failure);
var response = (ObjectResult)await Load(group, new MessageQuery { Before = 20, After = 2 });
Assert.That(response.StatusCode, Is.EqualTo(status));
Assert.That(((ProblemDetails)response.Value!).Extensions["errorCode"], Is.EqualTo("Chat.Failed"));
}
[TestCase(false)]
[TestCase(true)]
public async Task UnexpectedExceptionReturns500(bool group)
{
_loader.Setup(l => l.LoadMessagesInChatGroup(_chat, _user, null, 20, 2)).ThrowsAsync(new Exception("database unavailable"));
_loader.Setup(l => l.LoadMessagesInUserChat(_chat, _user, null, 20, 2)).ThrowsAsync(new Exception("database unavailable"));
Assert.That(((ObjectResult)await Load(group, new MessageQuery { Before = 20, After = 2 })).StatusCode, Is.EqualTo(500));
}
}
@@ -0,0 +1,79 @@
using AutoMapper;
using Govor.API.Controllers;
using Govor.API.Hubs;
using Govor.Application.Infrastructure.Extensions;
using Govor.Application.Medias;
using Govor.Application.Profiles;
using Govor.Application.PushNotifications;
using Govor.Application.Users.UserSessions;
using Govor.Application.Users.UserOnlineStatus;
using Govor.Application.PingHandler;
using Govor.Contracts.Requests;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.API.Tests.Unit.Controllers;
[TestFixture]
public class ControllerFailureTests
{
[TestCase(0,false)] [TestCase(0,true)] [TestCase(1,false)] [TestCase(1,true)] [TestCase(2,false)] [TestCase(2,true)]
public async Task SessionRevocationExceptionsProduceExpectedStatus(int action,bool unauthorized)
{
var user=new Mock<ICurrentUserService>();var session=new Mock<ICurrentUserSessionService>();var revoker=new Mock<IUserSessionRevoker>();
Exception error=unauthorized?new UnauthorizedAccessException():new Exception("private detail");
revoker.Setup(x=>x.CloseSessionByIdAsync(It.IsAny<Guid>(),It.IsAny<Guid>())).ThrowsAsync(error);
revoker.Setup(x=>x.CloseAllSessionsAsync(It.IsAny<Guid>())).ThrowsAsync(error);
using var controller=new SessionController(NullLogger<SessionController>.Instance,user.Object,session.Object,Mock.Of<IUserSessionReader>(),revoker.Object,Mock.Of<IMapper>());
var response=action switch{0=>await controller.CloseSession(Guid.NewGuid()),1=>await controller.CloseCurrent(),_=>await controller.CloseAllSessions()};
if(unauthorized) Assert.That(response,Is.TypeOf<ForbidResult>());else {Assert.That(((ObjectResult)response).StatusCode,Is.EqualTo(500));Assert.That(((ObjectResult)response).Value,Is.Not.EqualTo("private detail"));}
}
[TestCase(false)] [TestCase(true)] public async Task ProfileByIdHandlesServiceExceptions(bool unauthorized)
{
var profiles=new Mock<IProfileService>();profiles.Setup(x=>x.GetUserProfileAsync(It.IsAny<Guid>())).ThrowsAsync(unauthorized?new UnauthorizedAccessException():new Exception("failure"));
var controller=new ProfileController(NullLogger<ProfileController>.Instance,Mock.Of<IMediaService>(),profiles.Object,Mock.Of<ICurrentUserService>(),Mock.Of<IHubContext<ProfileHub>>(),Mock.Of<IMapper>());
var response=await controller.DownloadProfileByUserId(Guid.NewGuid());
if(unauthorized) Assert.That(response,Is.TypeOf<ForbidResult>());else Assert.That(((ObjectResult)response).StatusCode,Is.EqualTo(500));
}
[Test] public async Task ProfileByIdMapsRequestedUser()
{
var id=Guid.NewGuid();var value=new UserProfile{Id=id};var profiles=new Mock<IProfileService>();profiles.Setup(x=>x.GetUserProfileAsync(id)).ReturnsAsync(value);
var mapper=new Mock<IMapper>();var dto=new Govor.Contracts.DTOs.UserProfileDto();mapper.Setup(x=>x.Map<Govor.Contracts.DTOs.UserProfileDto>(value)).Returns(dto);
var controller=new ProfileController(NullLogger<ProfileController>.Instance,Mock.Of<IMediaService>(),profiles.Object,Mock.Of<ICurrentUserService>(),Mock.Of<IHubContext<ProfileHub>>(),mapper.Object);
Assert.That(((OkObjectResult)await controller.DownloadProfileByUserId(id)).Value,Is.SameAs(dto));
}
[TestCase(0)] [TestCase(1)] [TestCase(2)] public async Task MediaUploadFailuresAreMapped(int kind)
{
var media=new Mock<IMediaService>();
if(kind==0) media.Setup(x=>x.UploadMediaAsync(It.IsAny<Media>())).ReturnsAsync(Result.Failure<MediaUploadResult>(Error.ServerError("storage","failure")));
else media.Setup(x=>x.UploadMediaAsync(It.IsAny<Media>())).ThrowsAsync(kind==1?new UnauthorizedAccessException():new Exception("failure"));
using var stream=new MemoryStream([1]);using var controller=new MediaController(NullLogger<MediaController>.Instance,media.Object,Mock.Of<IAccesserToDownloadMedia>(),Mock.Of<ICurrentUserService>());
var response=await controller.Upload(new(){FromFile=new FormFile(stream,0,1,"file","avatar.png"),OwnerType=MediaOwnerType.Avatar,MimeType="image/png"});
if(kind==1) Assert.That(response,Is.TypeOf<ForbidResult>());else Assert.That(((ObjectResult)response).StatusCode,Is.EqualTo(500));
}
[TestCase(0)] [TestCase(1)] public async Task MediaUploadRejectsMissingMimeAndOversizeBeforeStorage(int kind)
{
var media=new Mock<IMediaService>(MockBehavior.Strict);var file=new Mock<IFormFile>();file.SetupGet(x=>x.Length).Returns(kind==0?1:20_000_001);
using var controller=new MediaController(NullLogger<MediaController>.Instance,media.Object,Mock.Of<IAccesserToDownloadMedia>(),Mock.Of<ICurrentUserService>());
Assert.That(await controller.Upload(new(){FromFile=file.Object,OwnerType=MediaOwnerType.Avatar,MimeType=kind==0?" ":"image/png"}),Is.TypeOf<BadRequestObjectResult>());media.VerifyNoOtherCalls();
}
[Test] public async Task OnlineStatusReaderFailureProduces500()
{
var presence=new Mock<IUserPresenceReader>();presence.Setup(x=>x.GetLastSeenAsync(It.IsAny<Guid>())).ThrowsAsync(new Exception("failure"));
using var controller=new OnlinePingingController(NullLogger<OnlinePingingController>.Instance,Mock.Of<IPingHandlerService>(),Mock.Of<ICurrentUserService>(),presence.Object,Mock.Of<IOnlineUserStore>());
Assert.That(((ObjectResult)await controller.GetStatus(Guid.NewGuid())).StatusCode,Is.EqualTo(500));
}
[Test] public async Task PushRegistrationHidesUnexpectedServiceFailure()
{
var push=new Mock<IPushTokenService>();push.Setup(x=>x.AddOrUpdateTokenAsync(It.IsAny<Guid>(),It.IsAny<Guid>(),"token","android")).ThrowsAsync(new Exception("private detail"));
using var controller=new PushTokensController(push.Object,Mock.Of<ICurrentUserService>(),Mock.Of<ICurrentUserSessionService>(),NullLogger<PushTokensController>.Instance){ControllerContext=new(){HttpContext=new DefaultHttpContext()}};
var result=(ObjectResult)await controller.RegisterToken(new(){Token="token",Platform="android"});
Assert.That(result.StatusCode,Is.EqualTo(500));Assert.That(((ProblemDetails)result.Value!).Detail,Does.Not.Contain("private detail"));
}
}
@@ -1,26 +1,23 @@
using AutoFixture; using AutoFixture;
using AutoMapper; using AutoMapper;
using Govor.API.Controllers.Friends; using Govor.API.Controllers.Friends;
using Govor.Application.Interfaces.Friends;
using Govor.Application.Interfaces.Infrastructure.Extensions;
using Govor.Contracts.DTOs; using Govor.Contracts.DTOs;
using Govor.Domain.Models; using Govor.Domain.Models;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Moq; using Moq;
namespace Govor.API.Tests.IntegrationTests.Controllers; namespace Govor.API.Tests.Unit.Controllers;
[TestFixture] [TestFixture]
public class FriendsRequestQueryControllerTests public class FriendsRequestQueryControllerTests
{ {
private Fixture _fixture; private Fixture _fixture = null!;
private Mock<ILogger<FriendsRequestQueryController>> _loggerMock; private Mock<ILogger<FriendsRequestQueryController>> _loggerMock = null!;
private Mock<IFriendRequestQueryService> _friendsServiceMock; private Mock<IFriendRequestQueryService> _friendsServiceMock = null!;
private Mock<ICurrentUserService> _currentUserServiceMock; private Mock<ICurrentUserService> _currentUserServiceMock = null!;
private Mock<IMapper> _mapperMock; private Mock<IMapper> _mapperMock = null!;
private FriendsRequestQueryController _controller; private FriendsRequestQueryController _controller = null!;
[SetUp] [SetUp]
public void SetUp() public void SetUp()
{ {
@@ -76,7 +73,7 @@ public class FriendsRequestQueryControllerTests
} }
[Test] [Test]
public async Task GetIncomingRequests_Throws_InvalidOperationException_ReturnsBadRequest() public async Task GetIncomingRequests_ServiceFailure_Returns500()
{ {
// Arrange // Arrange
var currentId = _fixture.Create<Guid>(); var currentId = _fixture.Create<Guid>();
@@ -91,12 +88,7 @@ public class FriendsRequestQueryControllerTests
var result = await _controller.GetIncomingRequests(); var result = await _controller.GetIncomingRequests();
// Assert // Assert
Assert.That(result, Is.InstanceOf<OkObjectResult>()); Assert.That(((ObjectResult)result).StatusCode, Is.EqualTo(500));
var okResult = result as OkObjectResult;
List<FriendshipDto> value = okResult.Value as List<FriendshipDto>;
Assert.That(value, Is.Not.Null);
Assert.That(value.Count, Is.EqualTo(0));
} }
[Test] [Test]
@@ -156,7 +148,7 @@ public class FriendsRequestQueryControllerTests
} }
[Test] [Test]
public async Task GetResponses_Throws_InvalidOperationException_ReturnsEmptyList() public async Task GetResponses_ServiceFailure_Returns500()
{ {
// Arrange // Arrange
var currentId = _fixture.Create<Guid>(); var currentId = _fixture.Create<Guid>();
@@ -171,12 +163,7 @@ public class FriendsRequestQueryControllerTests
var result = await _controller.GetResponses(); var result = await _controller.GetResponses();
// Assert // Assert
Assert.That(result, Is.InstanceOf<OkObjectResult>()); Assert.That(((ObjectResult)result).StatusCode, Is.EqualTo(500));
var okResult = result as OkObjectResult;
List<FriendshipDto> value = okResult.Value as List<FriendshipDto>;
Assert.That(value, Is.Not.Null);
Assert.That(value.Count, Is.EqualTo(0));
} }
[Test] [Test]
@@ -2,26 +2,23 @@ using AutoFixture;
using AutoMapper; using AutoMapper;
using Govor.API.Controllers.Friends; using Govor.API.Controllers.Friends;
using Govor.Application.Exceptions.FriendsService; using Govor.Application.Exceptions.FriendsService;
using Govor.Application.Interfaces.Friends;
using Govor.Application.Interfaces.Infrastructure.Extensions;
using Govor.Contracts.DTOs; using Govor.Contracts.DTOs;
using Govor.Domain.Models.Users; using Govor.Domain.Models.Users;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Moq; using Moq;
namespace Govor.API.Tests.IntegrationTests.Controllers; namespace Govor.API.Tests.Unit.Controllers;
[TestFixture] [TestFixture]
public class FriendshipControllerTests public class FriendshipControllerTests
{ {
private Fixture _fixture; private Fixture _fixture = null!;
private Mock<ILogger<FriendshipController>> _loggerMock; private Mock<ILogger<FriendshipController>> _loggerMock = null!;
private Mock<IFriendshipService> _friendsServiceMock; private Mock<IFriendshipService> _friendsServiceMock = null!;
private Mock<ICurrentUserService> _currentUserServiceMock; private Mock<ICurrentUserService> _currentUserServiceMock = null!;
private Mock<IMapper> _mapperMock; private Mock<IMapper> _mapperMock = null!;
private FriendshipController _controller; private FriendshipController _controller = null!;
[SetUp] [SetUp]
public void SetUp() public void SetUp()
{ {
@@ -127,7 +124,7 @@ public class FriendshipControllerTests
} }
[Test] [Test]
public async Task GetFriends_InvalidOperationException_ReturnsBadRequest() public async Task GetFriends_ServiceFailure_Returns500()
{ {
// Arrange // Arrange
var currentId = _fixture.Create<Guid>(); var currentId = _fixture.Create<Guid>();
@@ -143,7 +140,7 @@ public class FriendshipControllerTests
var result = await _controller.GetFriends(); var result = await _controller.GetFriends();
// Assert // Assert
Assert.That(result, Is.InstanceOf<OkObjectResult>()); Assert.That(((ObjectResult)result).StatusCode, Is.EqualTo(500));
} }
[Test] [Test]
@@ -0,0 +1,112 @@
using System.ComponentModel.DataAnnotations;
using Govor.API.Controllers;
using Govor.Application.E2ee;
using Govor.Application.Medias;
using Govor.Contracts.Requests;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.API.Tests.Unit.Controllers;
[TestFixture]
public class MediaControllerTests
{
private Mock<IMediaService> _media = null!;
private Mock<IAccesserToDownloadMedia> _access = null!;
private MediaController _controller = null!;
private readonly Guid _user = Guid.NewGuid();
[SetUp]
public void SetUp()
{
_media = new Mock<IMediaService>();
_access = new Mock<IAccesserToDownloadMedia>();
var current = new Mock<ICurrentUserService>();
current.Setup(c => c.GetCurrentUserId()).Returns(_user);
_controller = new(NullLogger<MediaController>.Instance, _media.Object, _access.Object, current.Object);
}
private static MediaUploadRequest Request(string mime = E2eeProtocol.EncryptedMimeType, string key = "") =>
new() { FromFile = new FormFile(new MemoryStream(new byte[] { 1, 2, 3 }), 0, 3, "file", "encrypted.bin"),
Type = MediaType.File, MimeType = mime, EncryptedKey = key, OwnerType = MediaOwnerType.Message };
[Test]
public async Task EncryptedUploadPassesCiphertextWithoutKeysToService()
{
var upload = new MediaUploadResult(Guid.NewGuid(), "stored.bin");
_media.Setup(m => m.UploadMediaAsync(It.IsAny<Media>())).ReturnsAsync(upload);
var request = Request();
var validation = new List<ValidationResult>();
Assert.That(Validator.TryValidateObject(request, new ValidationContext(request), validation, true),
Is.True, string.Join("; ", validation.Select(v => v.ErrorMessage)));
Assert.That(((OkObjectResult)await _controller.Upload(request)).Value, Is.SameAs(upload));
_media.Verify(m => m.UploadMediaAsync(It.Is<Media>(data => data.UploaderId == _user &&
data.EncryptedKey == "" && data.Data.SequenceEqual(new byte[] { 1, 2, 3 }) &&
data.MimeType == E2eeProtocol.EncryptedMimeType && data.OwnerId == null)), Times.Once);
}
[TestCase("image/png", "")]
[TestCase(E2eeProtocol.EncryptedMimeType, "decryption-secret")]
public async Task PlaintextAttachmentOrLeakedKeyIsRejected(string mime, string key)
{
Assert.That(await _controller.Upload(Request(mime, key)), Is.TypeOf<BadRequestObjectResult>());
_media.VerifyNoOtherCalls();
}
[TestCase(MediaOwnerType.System)]
[TestCase(MediaOwnerType.GroupAvatar)]
[TestCase(MediaOwnerType.Reaction)]
public async Task UnsupportedOwnerIsRejected(MediaOwnerType type)
{
var request = Request();
request.OwnerType = type;
Assert.That(await _controller.Upload(request), Is.TypeOf<BadRequestObjectResult>());
_media.VerifyNoOtherCalls();
}
[Test]
public async Task MissingFileAndInvalidModelAreRejected()
{
var request = Request();
request.FromFile = null!;
Assert.That(await _controller.Upload(request), Is.TypeOf<BadRequestObjectResult>());
_controller.ModelState.AddModelError("file", "invalid");
Assert.That(await _controller.Upload(Request()), Is.TypeOf<BadRequestObjectResult>());
_media.VerifyNoOtherCalls();
}
[Test]
public async Task DownloadDeniesAccessBeforeLoadingFile()
{
Assert.That(await _controller.Download(Guid.NewGuid()), Is.TypeOf<ForbidResult>());
_media.VerifyNoOtherCalls();
}
[Test]
public async Task DownloadReturnsBytesAndSanitizesFileName()
{
var id = Guid.NewGuid();
_access.Setup(a => a.HasAccessAsync(id, _user)).ReturnsAsync(true);
_media.Setup(m => m.GetMediaByIdAsync(id)).ReturnsAsync(new Media(_user, DateTime.UtcNow,
"folder/encrypted.bin", new byte[] { 1, 2 }, MediaType.File, E2eeProtocol.EncryptedMimeType, "", MediaOwnerType.Message, null));
var response = (FileContentResult)await _controller.Download(id);
Assert.That(response.FileContents, Is.EqualTo(new byte[] { 1, 2 }));
Assert.That(response.FileDownloadName, Is.EqualTo("encrypted.bin"));
Assert.That(response.ContentType, Is.EqualTo(E2eeProtocol.EncryptedMimeType));
}
[TestCase(ErrorType.NotFound, 404)]
[TestCase(ErrorType.ServerError, 500)]
public async Task DownloadServiceFailureReturnsProblemDetails(ErrorType type, int status)
{
var id = Guid.NewGuid();
_access.Setup(a => a.HasAccessAsync(id, _user)).ReturnsAsync(true);
_media.Setup(m => m.GetMediaByIdAsync(id)).ReturnsAsync(Result.Failure<Media>(new Error("Media.Failed", "failure", type)));
Assert.That(((ObjectResult)await _controller.Download(id)).StatusCode, Is.EqualTo(status));
}
}
@@ -1,21 +1,18 @@
using Govor.API.Controllers; using Govor.API.Controllers;
using Govor.Application.Interfaces;
using Govor.Application.Interfaces.Infrastructure.Extensions;
using Govor.Application.PingHandler; using Govor.Application.PingHandler;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Moq; using Moq;
namespace Govor.API.Tests.IntegrationTests.Controllers; namespace Govor.API.Tests.Unit.Controllers;
[TestFixture] [TestFixture]
public class OnlinePingingControllerTests public class OnlinePingingControllerTests
{ {
private Mock<ILogger<OnlinePingingController>> _loggerMock; private Mock<ILogger<OnlinePingingController>> _loggerMock = null!;
private Mock<IPingHandlerService> _pingHandlerServiceMock; private Mock<IPingHandlerService> _pingHandlerServiceMock = null!;
private Mock<ICurrentUserService> _currentUserServiceMock; private Mock<ICurrentUserService> _currentUserServiceMock = null!;
private OnlinePingingController _controller; private OnlinePingingController _controller = null!;
[SetUp] [SetUp]
public void SetUp() public void SetUp()
{ {
@@ -23,7 +20,7 @@ public class OnlinePingingControllerTests
_pingHandlerServiceMock = new Mock<IPingHandlerService>(); _pingHandlerServiceMock = new Mock<IPingHandlerService>();
_currentUserServiceMock = new Mock<ICurrentUserService>(); _currentUserServiceMock = new Mock<ICurrentUserService>();
_controller = new OnlinePingingController(_loggerMock.Object, _pingHandlerServiceMock.Object, _controller = new OnlinePingingController(_loggerMock.Object, _pingHandlerServiceMock.Object,
_currentUserServiceMock.Object); _currentUserServiceMock.Object, Mock.Of<IUserPresenceReader>(), Mock.Of<IOnlineUserStore>());
} }
[Test] [Test]
@@ -44,7 +41,7 @@ public class OnlinePingingControllerTests
} }
[Test] [Test]
public async Task Ping_InvalidOperationException_ReturnsBadRequest() public async Task Ping_InvalidOperationException_Returns500()
{ {
// Arrange // Arrange
var userId = Guid.NewGuid(); var userId = Guid.NewGuid();
@@ -56,14 +53,12 @@ public class OnlinePingingControllerTests
var result = await _controller.Ping(); var result = await _controller.Ping();
// Assert // Assert
Assert.That(result, Is.InstanceOf<BadRequestObjectResult>()); Assert.That(((ObjectResult)result).StatusCode, Is.EqualTo(500));
var badRequestResult = (BadRequestObjectResult)result;
Assert.That(badRequestResult.Value, Is.EqualTo("User can't be found in our database."));
_loggerMock.VerifyLog(LogLevel.Error, exception.Message, Times.Once()); _loggerMock.VerifyLog(LogLevel.Error, exception.Message, Times.Once());
} }
[Test] [Test]
public async Task Ping_UnauthorizedAccessException_ReturnsForbid() public async Task Ping_ServiceException_Returns500()
{ {
// Arrange // Arrange
var userId = Guid.NewGuid(); var userId = Guid.NewGuid();
@@ -75,7 +70,7 @@ public class OnlinePingingControllerTests
var result = await _controller.Ping(); var result = await _controller.Ping();
// Assert // Assert
Assert.That(result, Is.InstanceOf<ForbidResult>()); Assert.That(((ObjectResult)result).StatusCode, Is.EqualTo(500));
_loggerMock.VerifyLog(LogLevel.Error, exception.Message, Times.Once()); _loggerMock.VerifyLog(LogLevel.Error, exception.Message, Times.Once());
} }
@@ -99,7 +94,7 @@ public class OnlinePingingControllerTests
} }
[Test] [Test]
public async Task Ping_UnauthorizedUserId_ThrowsUnauthorizedAccessException() public async Task Ping_CurrentUserException_Returns500WithoutPinging()
{ {
// Arrange // Arrange
var exception = new UnauthorizedAccessException("userID claim is missing or invalid"); var exception = new UnauthorizedAccessException("userID claim is missing or invalid");
@@ -109,7 +104,7 @@ public class OnlinePingingControllerTests
var result = await _controller.Ping(); var result = await _controller.Ping();
// Assert // Assert
Assert.That(result, Is.InstanceOf<ForbidResult>()); Assert.That(((ObjectResult)result).StatusCode, Is.EqualTo(500));
_loggerMock.VerifyLog(LogLevel.Error, exception.Message, Times.Once()); _loggerMock.VerifyLog(LogLevel.Error, exception.Message, Times.Once());
_pingHandlerServiceMock.Verify(x => x.Ping(It.IsAny<Guid>()), Times.Never()); _pingHandlerServiceMock.Verify(x => x.Ping(It.IsAny<Guid>()), Times.Never());
} }
@@ -133,7 +128,7 @@ public static class LoggerMockExtensions
It.IsAny<EventId>(), It.IsAny<EventId>(),
It.Is<It.IsAnyType>((v, t) => v.ToString().Contains(message)), It.Is<It.IsAnyType>((v, t) => v.ToString().Contains(message)),
It.IsAny<Exception>(), It.IsAny<Exception>(),
It.IsAny<Func<It.IsAnyType, Exception, string>>()), It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
times); times);
} }
} }
@@ -0,0 +1,59 @@
using Govor.API.Controllers;
using Govor.Application.Friends;
using Govor.Application.Exceptions.VerifyFriendship;
using Govor.Application.Infrastructure.Extensions;
using Govor.Application.PrivateUserChats;
using Govor.Contracts.DTOs;
using Govor.Domain.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.API.Tests.Unit.Controllers;
[TestFixture]
public class PrivateChatControllerTests
{
private readonly Guid _user=Guid.NewGuid(),_friend=Guid.NewGuid();
private Mock<IVerifyFriendship> _verify=null!;
private Mock<IUserPrivateChatsCreator> _creator=null!;
private Mock<IUserPrivateChatsGetterService> _getter=null!;
private PrivateChatController _controller=null!;
[SetUp] public void Setup()
{
_verify=new(); _creator=new(); _getter=new();
var user=new Mock<ICurrentUserService>(); user.Setup(x=>x.GetCurrentUserId()).Returns(_user);
_controller=new(user.Object,_verify.Object,_creator.Object,_getter.Object,NullLogger<ChatLoadController>.Instance);
}
[TearDown] public void TearDown()=>_controller.Dispose();
[Test] public async Task FriendshipIsVerifiedBeforeCreatingChat()
{
var order=new List<string>(); var chat=new PrivateChat{Id=Guid.NewGuid()};
_verify.Setup(x=>x.VerifyAsync(_user,_friend)).Callback(()=>order.Add("verify")).Returns(Task.CompletedTask);
_creator.Setup(x=>x.CreateAsync(_user,_friend)).Callback(()=>order.Add("create")).ReturnsAsync(chat);
Assert.That(((OkObjectResult)await _controller.GetChatByFriendId(_friend)).Value,Is.EqualTo(chat.Id));
Assert.That(order,Is.EqualTo(new[]{"verify","create"}));
}
[TestCase(0)] [TestCase(1)] [TestCase(2)] [TestCase(3)]
public async Task VerificationFailuresNeverCreateChat(int kind)
{
Exception error=kind switch{0=>new UnauthorizedAccessException(),1=>new ArgumentException("invalid"),2=>new FriendshipException("denied"),_=>new Exception("private")};
_verify.Setup(x=>x.VerifyAsync(_user,_friend)).ThrowsAsync(error);
var result=await _controller.GetChatByFriendId(_friend);
if(kind is 0 or 2) Assert.That(result,Is.TypeOf<ForbidResult>());
else Assert.That(((ObjectResult)result).StatusCode,Is.EqualTo(kind==1?400:500));
_creator.VerifyNoOtherCalls();
}
[Test] public async Task ChatListSelectsOtherParticipantForBothOrientations()
{
_getter.Setup(x=>x.GetUserChatsAsync(_user)).ReturnsAsync([new(){Id=Guid.NewGuid(),UserAId=_user,UserBId=_friend},new(){Id=Guid.NewGuid(),UserAId=_friend,UserBId=_user}]);
var result=(List<PrivateChatDto>)((OkObjectResult)await _controller.GetChatsByFriends()).Value!;
Assert.That(result.Select(x=>x.FriendId),Is.EqualTo(new[]{_friend,_friend}));
}
[TestCase(false)] [TestCase(true)] public async Task ChatListHandlesErrors(bool unauthorized)
{
_getter.Setup(x=>x.GetUserChatsAsync(_user)).ThrowsAsync(unauthorized?new UnauthorizedAccessException():new Exception("private"));
var result=await _controller.GetChatsByFriends();
if(unauthorized) Assert.That(result,Is.TypeOf<ForbidResult>()); else Assert.That(((ObjectResult)result).StatusCode,Is.EqualTo(500));
}
}
@@ -1,16 +1,12 @@
using System.Text; using System.Text;
using AutoMapper; using AutoMapper;
using Govor.API.Controllers; using Govor.API.Controllers;
using Govor.API.Hubs; using Govor.API.Hubs;
using Govor.Application.Interfaces;
using Govor.Application.Interfaces.Infrastructure.Extensions;
using Govor.Application.Interfaces.Medias;
using Govor.Application.Profiles; using Govor.Application.Profiles;
using Govor.Contracts.DTOs; using Govor.Contracts.DTOs;
using Govor.Contracts.Requests; using Govor.Contracts.Requests;
using Govor.Domain.Models; using Govor.Domain.Models;
using Govor.Domain.Models.Messages; using Govor.Domain.Models.Messages;
using Govor.Data.Repositories.Exceptions;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR; using Microsoft.AspNetCore.SignalR;
@@ -34,7 +30,6 @@ private Mock<ILogger<ProfileController>> _mockLogger = null!;
private ProfileController _controller = null!; private ProfileController _controller = null!;
private Guid _userId; private Guid _userId;
[SetUp] [SetUp]
public void SetUp() public void SetUp()
{ {
@@ -137,7 +132,7 @@ private Mock<ILogger<ProfileController>> _mockLogger = null!;
.ReturnsAsync(expectedMediaInfo); .ReturnsAsync(expectedMediaInfo);
_mockProfileService.Setup(s => s.SetNewIcon(_userId, mediaId)) _mockProfileService.Setup(s => s.SetNewIcon(_userId, mediaId))
.Returns(Task.CompletedTask); .ReturnsAsync(Govor.Domain.Common.Result.Success());
// Act // Act
var result = await _controller.UploadAvatar(request); var result = await _controller.UploadAvatar(request);
@@ -240,19 +235,20 @@ private Mock<ILogger<ProfileController>> _mockLogger = null!;
} }
[Test] [Test]
public async Task DowloadProfile_ReturnsBadRequest_WhenNotFoundExceptionThrown() public async Task DownloadProfile_MissingProfile_Returns404ProblemDetails()
{ {
// Arrange // Arrange
_mockProfileService.Setup(s => s.GetUserProfileAsync(_userId)) _mockProfileService.Setup(s => s.GetUserProfileAsync(_userId))
.ThrowsAsync(new NotFoundException("Cannot find profile")); .ReturnsAsync(Govor.Domain.Common.Result.Failure<UserProfile>(
Govor.Domain.Common.Error.NotFound("Profile.UserNotFound", "Cannot find profile")));
// Act // Act
var result = await _controller.DownloadProfile(); var result = await _controller.DownloadProfile();
// Assert // Assert
var notFoundResult = result as NotFoundObjectResult; var response = (ObjectResult)result;
Assert.That(notFoundResult, Is.Not.Null); Assert.That(response.StatusCode, Is.EqualTo(404));
Assert.That(notFoundResult!.Value, Is.EqualTo("Profile not found")); Assert.That(((ProblemDetails)response.Value!).Extensions["errorCode"], Is.EqualTo("Profile.UserNotFound"));
} }
[Test] [Test]
@@ -0,0 +1,92 @@
using AutoMapper;
using Govor.API.Controllers;
using Govor.API.Controllers.AdminStuff;
using Govor.Application.Infrastructure.Extensions;
using Govor.Application.Reactions;
using Govor.Contracts.Responses;
using Govor.Domain.Common;
using Govor.Domain.Models.Reactions;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Moq;
namespace Govor.API.Tests.Unit.Controllers;
[TestFixture]
public class ReactionPackControllerTests
{
private readonly Guid _user=Guid.NewGuid(),_pack=Guid.NewGuid(),_reaction=Guid.NewGuid();
private Mock<IReactionPackService> _packs=null!;
private Mock<IMapper> _mapper=null!;
private ReactionPacksController _controller=null!;
private ReactionPacksAdminController _admin=null!;
private ReactionPackResponse _packResponse=null!;
private ReactionItemResponse _itemResponse=null!;
[SetUp] public void Setup()
{
_packs=new();_mapper=new();var user=new Mock<ICurrentUserService>();user.Setup(x=>x.GetCurrentUserId()).Returns(_user);
_packResponse=new();_itemResponse=new();
_mapper.Setup(x=>x.Map<ReactionPackResponse>(It.IsAny<object>())).Returns(_packResponse);
_mapper.Setup(x=>x.Map<ReactionItemResponse>(It.IsAny<object>())).Returns(_itemResponse);
_controller=new(_packs.Object,user.Object,_mapper.Object);
_admin=new(_packs.Object,user.Object,_mapper.Object){ControllerContext=new(){HttpContext=new DefaultHttpContext()}};
}
[TestCase(false)] [TestCase(true)] public async Task ListsForwardPaginationAndVisibility(bool admin)
{
var list=new List<ReactionPack>();var mapped=new List<ReactionPackResponse>();
_packs.Setup(x=>x.ListAsync(_user,false,admin,7,9)).ReturnsAsync(list);
_mapper.Setup(x=>x.Map<List<ReactionPackResponse>>(list)).Returns(mapped);
var result=admin?await _admin.List(7,9):await _controller.List(7,9);
Assert.That(((OkObjectResult)result).Value,Is.SameAs(mapped));
_packs.Verify(x=>x.ListAsync(_user,false,admin,7,9),Times.Once);
_packs.Setup(x=>x.ListAsync(_user,true,false,4,6)).ReturnsAsync(list);
Assert.That(((OkObjectResult)await _controller.Mine(4,6)).Value,Is.SameAs(mapped));
_packs.Verify(x=>x.ListAsync(_user,true,false,4,6),Times.Once);
}
[TestCase(false)] [TestCase(true)] public async Task GetMapsSuccessfulPackOrPreservesFailure(bool failure)
{
_packs.Setup(x=>x.GetAsync(_pack,It.IsAny<bool>())).ReturnsAsync(failure?Result.Failure<ReactionPack>(Error.NotFound("missing","missing")):new ReactionPack());
foreach(var result in new[]{await _controller.Get(_pack),await _admin.Get(_pack)})
if(failure) Assert.That(((ObjectResult)result).StatusCode,Is.EqualTo(404));else Assert.That(((OkObjectResult)result).Value,Is.SameAs(_packResponse));
_packs.Verify(x=>x.GetAsync(_pack,true),Times.Once);_packs.Verify(x=>x.GetAsync(_pack,false),Times.Once);
}
[Test] public async Task SharedAndReactionMapContracts()
{
_packs.Setup(x=>x.GetSharedAsync("share")).ReturnsAsync(new ReactionPack());_packs.Setup(x=>x.GetReactionAsync(_reaction)).ReturnsAsync(new ReactionItem());
Assert.That(((OkObjectResult)await _controller.Shared("share")).Value,Is.SameAs(_packResponse));
Assert.That(((OkObjectResult)await _controller.Reaction(_reaction)).Value,Is.SameAs(_itemResponse));
Assert.That(_controller.Limits(),Is.TypeOf<OkObjectResult>());
}
[TestCase(false)] [TestCase(true)] public async Task SubscriptionsForwardDesiredState(bool subscribe)
{
_packs.Setup(x=>x.SubscribeAsync(_user,_pack,subscribe)).ReturnsAsync(SmartRes.Unit.Value);
var result=subscribe?await _controller.Subscribe(_pack):await _controller.Unsubscribe(_pack);
Assert.That(((StatusCodeResult)result).StatusCode,Is.EqualTo(204));_packs.Verify(x=>x.SubscribeAsync(_user,_pack,subscribe),Times.Once);
}
[Test] public async Task AdminMutationsForwardActorFieldsAndMapContracts()
{
_packs.Setup(x=>x.CreateAsync(_user,"name","desc")).ReturnsAsync(new ReactionPack());
_packs.Setup(x=>x.UpdateAsync(_user,_pack,"new","changed",false)).ReturnsAsync(new ReactionPack());
_packs.Setup(x=>x.DisableAsync(_user,_pack)).ReturnsAsync(SmartRes.Unit.Value);
_packs.Setup(x=>x.AddEmojiAsync(_user,_pack,"emoji","👍")).ReturnsAsync(new ReactionItem());
_packs.Setup(x=>x.DisableReactionAsync(_user,_pack,_reaction)).ReturnsAsync(SmartRes.Unit.Value);
Assert.That(((OkObjectResult)await _admin.Create(new(){Name="name",Description="desc"})).Value,Is.SameAs(_packResponse));
Assert.That(((OkObjectResult)await _admin.Update(_pack,new(){Name="new",Description="changed",IsEnabled=false})).Value,Is.SameAs(_packResponse));
Assert.That(((StatusCodeResult)await _admin.Disable(_pack)).StatusCode,Is.EqualTo(204));
Assert.That(((OkObjectResult)await _admin.Emoji(_pack,new(){Name="emoji",Emoji="👍"})).Value,Is.SameAs(_itemResponse));
Assert.That(((StatusCodeResult)await _admin.DisableReaction(_pack,_reaction)).StatusCode,Is.EqualTo(204));
}
[TestCase(-1)] [TestCase(0)] [TestCase(2_097_153)] public async Task MediaRejectsMissingEmptyOrOversizedFile(int length)
{
var file=new Mock<IFormFile>();file.SetupGet(x=>x.Length).Returns(length);
Assert.That(await _admin.Media(_pack,new(){File=length<0?null!:file.Object}),Is.TypeOf<BadRequestObjectResult>());_packs.VerifyNoOtherCalls();
}
[Test] public async Task MediaCopiesBytesAndPassesRequestCancellation()
{
using var stream=new MemoryStream([1,2,3]);using var cancellation=new CancellationTokenSource();_admin.HttpContext.RequestAborted=cancellation.Token;
_packs.Setup(x=>x.AddMediaAsync(_user,_pack,"image",It.Is<byte[]>(b=>b.SequenceEqual(new byte[]{1,2,3})),cancellation.Token)).ReturnsAsync(new ReactionItem());
var result=await _admin.Media(_pack,new(){Name="image",File=new FormFile(stream,0,3,"file","image.png")});
Assert.That(((OkObjectResult)result).Value,Is.SameAs(_itemResponse));
_packs.Verify(x=>x.AddMediaAsync(_user,_pack,"image",It.IsAny<byte[]>(),cancellation.Token),Times.Once);
}
}
@@ -0,0 +1,93 @@
using AutoMapper;
using Govor.API.Controllers;
using Govor.Application.Users.UserSessions;
using Govor.Contracts.DTOs;
using Govor.Domain.Common;
using Govor.Domain.Models.Users;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.API.Tests.Unit.Controllers;
[TestFixture]
public class SessionControllerTests
{
private SessionController _controller = null!;
private Mock<IUserSessionReader> _reader = null!;
private Mock<IUserSessionRevoker> _revoker = null!;
private Mock<IMapper> _mapper = null!;
private readonly Guid _user = Guid.NewGuid(), _session = Guid.NewGuid();
[SetUp]
public void SetUp()
{
_reader = new Mock<IUserSessionReader>();
_revoker = new Mock<IUserSessionRevoker>();
_mapper = new Mock<IMapper>();
var current = new Mock<ICurrentUserService>();
current.Setup(c => c.GetCurrentUserId()).Returns(_user);
var session = new Mock<ICurrentUserSessionService>();
session.Setup(s => s.GetUserSessionId()).Returns(_session);
_controller = new(NullLogger<SessionController>.Instance, current.Object,
session.Object, _reader.Object, _revoker.Object, _mapper.Object);
}
[Test]
public async Task SessionsAreReadForCurrentUserAndMapped()
{
var sessions = new List<UserSession> { new() { Id = _session, UserId = _user } };
var dtos = new List<SessionDto> { new() { Id = _session } };
_reader.Setup(r => r.GetAllSessionsAsync(_user)).ReturnsAsync(sessions);
_mapper.Setup(m => m.Map<List<SessionDto>>(sessions)).Returns(dtos);
Assert.That(((OkObjectResult)await _controller.GetAllSessions()).Value, Is.SameAs(dtos));
}
[Test]
public async Task CloseActionsReturn204AndUseCurrentOwner()
{
_revoker.Setup(r => r.CloseSessionByIdAsync(_session, _user)).ReturnsAsync(Result.Success());
_revoker.Setup(r => r.CloseAllSessionsAsync(_user)).ReturnsAsync(Result.Success());
Assert.That(((StatusCodeResult)await _controller.CloseSession(_session)).StatusCode, Is.EqualTo(204));
Assert.That(((StatusCodeResult)await _controller.CloseCurrent()).StatusCode, Is.EqualTo(204));
Assert.That(((StatusCodeResult)await _controller.CloseAllSessions()).StatusCode, Is.EqualTo(204));
_revoker.Verify(r => r.CloseSessionByIdAsync(_session, _user), Times.Exactly(2));
_revoker.Verify(r => r.CloseAllSessionsAsync(_user), Times.Once);
}
[Test]
public async Task EmptySessionIdDoesNotRevokeAnything()
{
Assert.That(await _controller.CloseSession(Guid.Empty), Is.TypeOf<BadRequestObjectResult>());
_revoker.VerifyNoOtherCalls();
}
[TestCase(ErrorType.NotFound, 404)]
[TestCase(ErrorType.Conflict, 409)]
[TestCase(ErrorType.Forbidden, 403)]
public async Task CloseFailuresReturnProblemDetails(ErrorType type, int status)
{
_revoker.Setup(r => r.CloseSessionByIdAsync(_session, _user))
.ReturnsAsync(Result.Failure(new Error("Session.Failed", "failure", type)));
foreach (var action in new Func<Task<IActionResult>>[] { () => _controller.CloseSession(_session), _controller.CloseCurrent })
{
var response = (ObjectResult)await action();
Assert.That(response.StatusCode, Is.EqualTo(status));
Assert.That(((ProblemDetails)response.Value!).Extensions["errorCode"], Is.EqualTo("Session.Failed"));
}
}
[Test]
public async Task UnauthorizedCurrentUserReturnsForbid()
{
_reader.Setup(r => r.GetAllSessionsAsync(_user)).ThrowsAsync(new UnauthorizedAccessException());
Assert.That(await _controller.GetAllSessions(), Is.TypeOf<ForbidResult>());
}
[Test]
public async Task UnexpectedReaderExceptionReturns500()
{
_reader.Setup(r => r.GetAllSessionsAsync(_user)).ThrowsAsync(new Exception("database unavailable"));
Assert.That(((ObjectResult)await _controller.GetAllSessions()).StatusCode, Is.EqualTo(500));
}
}
@@ -0,0 +1,92 @@
using Govor.API.Controllers.Authentication;
using Govor.Application.Friends;
using Govor.Application.Infrastructure.Extensions;
using Govor.Application.Users.UserSessions.Crypto;
using Govor.Contracts.Requests;
using Govor.Contracts.DTOs;
using Govor.Domain.Models.Users;
using Govor.Domain.Models.Users.Crypto;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.API.Tests.Unit.Controllers;
[TestFixture]
public class SessionKeysControllerTests
{
private readonly Guid _user = Guid.NewGuid(), _session = Guid.NewGuid(), _friend = Guid.NewGuid();
private Mock<IFriendshipService> _friends = null!;
private Mock<ISessionKeyAttacher> _attacher = null!;
private Mock<ISessionKeysReader> _reader = null!;
private Mock<IOneTimePreKeysRotator> _rotator = null!;
private SessionKeysController _controller = null!;
[SetUp]
public void Setup()
{
_friends = new(); _attacher = new(); _reader = new(); _rotator = new();
var user = new Mock<ICurrentUserService>(); user.Setup(x => x.GetCurrentUserId()).Returns(_user);
var session = new Mock<ICurrentUserSessionService>(); session.Setup(x => x.GetUserSessionId()).Returns(_session);
_controller = new(NullLogger<SessionKeysController>.Instance, _friends.Object, session.Object, _attacher.Object, _reader.Object, user.Object, _rotator.Object);
}
[TestCase(false, 0)] [TestCase(false, 100)] [TestCase(false, 101)] [TestCase(true, 1)]
public async Task UploadValidatesModelAndKeyCount(bool invalidModel, int count)
{
var request = new UploadKeysRequest { IdentityKey = [1], SignedPreKey = [2], SignedPreKeySignature = [3], OneTimePreKeys = Enumerable.Range(0,count).Select(_ => new byte[] {4}).ToList() };
if (invalidModel) _controller.ModelState.AddModelError("keys", "invalid");
var result = await _controller.UploadSessionKeys(request);
if (invalidModel || count > 100) { Assert.That(result, Is.TypeOf<BadRequestObjectResult>()); _attacher.VerifyNoOtherCalls(); }
else {
Assert.That(result, Is.TypeOf<OkResult>());
_attacher.Verify(x => x.AttachKeysAsync(_session, request.IdentityKey, request.SignedPreKey, request.SignedPreKeySignature, request.OneTimePreKeys), Times.Once);
}
}
[TestCase(false, 0)] [TestCase(false, 100)] [TestCase(false, 101)] [TestCase(true, 1)]
public async Task RotationValidatesAndUsesAuthenticatedSession(bool invalidModel, int count)
{
var request = new RotateOneTimePreKeysRequest { NewOneTimePreKeys = Enumerable.Range(0,count).Select(_ => new byte[] {4}).ToList() };
if (invalidModel) _controller.ModelState.AddModelError("keys", "invalid");
var result = await _controller.RotateOneTimePreKeys(request);
if (invalidModel || count > 100) { Assert.That(result, Is.TypeOf<BadRequestObjectResult>()); _rotator.VerifyNoOtherCalls(); }
else { Assert.That(result, Is.TypeOf<OkObjectResult>()); _rotator.Verify(x => x.RotateOneTimePreKeysAsync(_session, request.NewOneTimePreKeys), Times.Once); }
}
[Test]
public async Task NonFriendCannotReadKeys()
{
_friends.Setup(x => x.GetFriendsAsync(_friend)).ReturnsAsync([]);
Assert.That(await _controller.GetUserPublicKeys(_friend), Is.TypeOf<ForbidResult>());
_reader.VerifyNoOtherCalls();
}
[Test]
public async Task FriendKeysAreBase64AndUsedPrekeysAreExcluded()
{
_friends.Setup(x => x.GetFriendsAsync(_friend)).ReturnsAsync([new User { Id = _user }]);
var unusedId = Guid.NewGuid();
_reader.Setup(x => x.GetAllActiveKeysAsync(_friend)).ReturnsAsync([
new UserCryptoSession { PublicIdentityKey = [1], SignedPreKey = new() { Id = Guid.NewGuid(), PublicSignedPreKey = [2], SignedPreKeySignature = [3] }, OneTimePreKeys = [new() {Id = unusedId, PublicKey = [4]}, new() {Id = Guid.NewGuid(), PublicKey = [5], IsUsed = true}] },
new UserCryptoSession { PublicIdentityKey = [6], SignedPreKey = null!, OneTimePreKeys = [] }
]);
var dtos = ((IEnumerable<PublicSessionKeysDto>)((OkObjectResult)await _controller.GetUserPublicKeys(_friend)).Value!).ToList();
Assert.Multiple(() => {
Assert.That(dtos[0].IdentityKey, Is.EqualTo("AQ==")); Assert.That(dtos[0].SignedPreKey!.Key, Is.EqualTo("Ag=="));
Assert.That(dtos[0].SignedPreKey!.Signature, Is.EqualTo("Aw==")); Assert.That(dtos[0].OneTimePreKeys.Single().Id, Is.EqualTo(unusedId));
Assert.That(dtos[0].OneTimePreKeys.Single().Key, Is.EqualTo("BA==")); Assert.That(dtos[1].SignedPreKey, Is.Null);
});
}
[Test]
public async Task CountAndConsumptionUseAuthenticatedSession()
{
_reader.Setup(x => x.GetRemainingOneTimePreKeysCountAsync(_session)).ReturnsAsync(17);
var result = (OkObjectResult)await _controller.GetRemainingOneTimePreKeysCount();
Assert.That(result.Value!.GetType().GetProperty("remaining")!.GetValue(result.Value), Is.EqualTo(17));
var key = Guid.NewGuid();
Assert.That(await _controller.MarkOneTimePreKeyAsUsed(key), Is.TypeOf<OkObjectResult>());
_rotator.Verify(x => x.MarkOneTimePreKeyAsUsedAsync(_session, key), Times.Once);
}
}
@@ -0,0 +1,191 @@
using AutoMapper;
using Govor.API.Common.SignalR.Helpers;
using Govor.API.Hubs;
using Govor.API.Hubs.Infrastructure;
using Govor.Application.Exceptions.VerifyFriendship;
using Govor.Application.Infrastructure.Common;
using Govor.Application.Messages;
using Govor.Application.Messages.Parameters;
using Govor.Application.Reactions;
using Govor.Contracts.Requests;
using Govor.Contracts.Requests.SignalR;
using Govor.Contracts.Responses.SignalR;
using Govor.Domain.Common;
using Govor.Domain.Models.Messages;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using System.Security.Claims;
namespace Govor.API.Tests.Unit.Hubs;
[TestFixture]
public class ChatsHubTests
{
private readonly Guid _user = Guid.NewGuid(), _chat = Guid.NewGuid();
private readonly DateTime _now = new(2026,10,24,0,0,0,DateTimeKind.Utc);
private Mock<IMessageReadingService> _read = null!;
private Mock<IMessageSendingService> _send = null!;
private Mock<IMessageEditingService> _edit = null!;
private Mock<IMessageRemovingService> _remove = null!;
private Mock<IMessageReactionService> _reactions = null!;
private Mock<IChatNotificationService> _notifier = null!;
private Mock<IHubUserAccessor> _userAccessor = null!;
private Mock<IConnectionManager> _connections = null!;
private Mock<HubCallerContext> _context = null!;
private Mock<IGroupManager> _groups = null!;
private Mock<IMapper> _mapper = null!;
private ChatsHub _hub = null!;
private Message Message() => new() { Id=Guid.NewGuid(),SenderId=_user,RecipientId=_chat,RecipientType=RecipientType.User,EncryptedContent="cipher",SentAt=_now };
[SetUp]
public void Setup()
{
_read=new(); _send=new(); _edit=new(); _remove=new(); _reactions=new(); _notifier=new(); _connections=new(); _groups=new(); _mapper=new(); _context=new(); _userAccessor=new();
_userAccessor.Setup(x=>x.GetUserId(It.IsAny<HubCallerContext>(),It.IsAny<bool>())).Returns(_user);
var clock=new Mock<INowDateTimeProvider>(); clock.SetupGet(x=>x.Now).Returns(_now);
_context.SetupGet(x=>x.ConnectionId).Returns("connection");
_context.SetupGet(x=>x.User).Returns(new ClaimsPrincipal(new ClaimsIdentity(new[]{new Claim("sid",_chat.ToString())})));
_hub=new(NullLogger<ChatsHub>.Instance,_read.Object,_send.Object,_edit.Object,_remove.Object,_userAccessor.Object,_notifier.Object,clock.Object,_connections.Object,_reactions.Object,_mapper.Object) {Context=_context.Object,Groups=_groups.Object};
}
[TearDown] public void TearDown()=>_hub.Dispose();
[TestCase(false)] [TestCase(true)]
public async Task LifecycleMaintainsConnectionAndSessionGroup(bool error)
{
await _hub.OnConnectedAsync(); await _hub.OnDisconnectedAsync(error?new Exception("disconnect"):null);
_connections.Verify(x=>x.OnConnectedAsync("connection",_user),Times.Once);
_connections.Verify(x=>x.OnDisconnectedAsync("connection",_user),Times.Once);
_groups.Verify(x=>x.AddToGroupAsync("connection",ChatHubConstants.GetSessionGroup(_chat),default),Times.Once);
}
[TestCase(false)] [TestCase(true)]
public async Task MissingUserOrSessionAbortsConnection(bool missingUser)
{
if(missingUser) _userAccessor.Setup(x=>x.GetUserId(It.IsAny<HubCallerContext>(),It.IsAny<bool>())).Returns(Guid.Empty);
else _context.SetupGet(x=>x.User).Returns(new ClaimsPrincipal());
await _hub.OnConnectedAsync(); _context.Verify(x=>x.Abort(),Times.Once); _groups.VerifyNoOtherCalls();
}
[TestCase(false)] [TestCase(true)]
public async Task SendMapsActorClockReplyAndMediaThenNotifies(bool media)
{
var message=Message(); var mediaId=Guid.NewGuid(); var reply=Guid.NewGuid();
if (media) message.MediaAttachments = [new() { MediaFile = new() { Id = mediaId } }];
_send.Setup(x=>x.SendMessageAsync(It.IsAny<SendMessage>())).ReturnsAsync(new SendMessageResult(true,null,message));
var response=await _hub.Send(new() {RecipientId=_chat,EncryptedContent="cipher",ReplyToMessageId=reply,MediaAttachments=media?[new(){MediaId=mediaId,EncryptedKey="key"}]:null!});
Assert.That(response.Status,Is.EqualTo(HubResultStatus.Success));
Assert.That(response.Result!.ReplyToMessageId,Is.EqualTo(reply));
Assert.That(response.Result.MediaAttachments.Select(m => m.Id), Is.EqualTo(media ? new[] { mediaId } : Array.Empty<Guid>()));
_send.Verify(x=>x.SendMessageAsync(It.Is<SendMessage>(p=>p.FromUserId==_user && p.RecipientId==_chat && p.SendAt==_now && p.ReplyToMessageId==reply && p.Media.Count()==(media?1:0))),Times.Once);
_notifier.Verify(x=>x.NotifyMessageSentAsync(response.Result!),Times.Once);
}
[TestCase(0)] [TestCase(1)] [TestCase(2)] [TestCase(3)]
public async Task InvalidSendNeverInvokesService(int kind)
{
MessageRequest? request=kind switch {0=>null,1=>new(){EncryptedContent=" "},2=>new(){EncryptedContent=new string('a',1_000_001)},_=>new(){EncryptedContent="",MediaAttachments=null!}};
Assert.That((await _hub.Send(request!)).Status,Is.EqualTo(HubResultStatus.BadRequest)); _send.VerifyNoOtherCalls(); _notifier.VerifyNoOtherCalls();
}
[TestCase(0,HubResultStatus.Forbidden)] [TestCase(1,HubResultStatus.Unauthorized)]
[TestCase(2,HubResultStatus.BadRequest)] [TestCase(3,HubResultStatus.NotFound)]
[TestCase(4,HubResultStatus.BadRequest)] [TestCase(5,HubResultStatus.ServerError)]
public async Task ServiceExceptionsMapToHubStatus(int kind,HubResultStatus expected)
{
Exception error=kind switch {0=>new UnauthorizedAccessException(),1=>new FriendshipException("friend"),2=>new ArgumentException("invalid"),3=>new KeyNotFoundException(),4=>new InvalidOperationException("conflict"),_=>new Exception("private detail")};
_send.Setup(x=>x.SendMessageAsync(It.IsAny<SendMessage>())).ReturnsAsync(new SendMessageResult(false,error,null!));
var response=await _hub.Send(new(){EncryptedContent="cipher"}); Assert.That(response.Status,Is.EqualTo(expected));
if(kind==5) Assert.That(response.ErrorMessage,Does.Not.Contain("private detail"));
_notifier.VerifyNoOtherCalls();
}
[Test]
public async Task SendFailureWithoutExceptionIsBadRequest()
{
_send.Setup(x=>x.SendMessageAsync(It.IsAny<SendMessage>())).ReturnsAsync(new SendMessageResult(false,null,null!));
Assert.That((await _hub.Send(new(){EncryptedContent="cipher"})).Status,Is.EqualTo(HubResultStatus.BadRequest));
}
[Test]
public async Task ReadMapsCurrentReadersViewAndNotifies()
{
var message=Message(); var view=new MessageView{Id=Guid.NewGuid(),UserId=_user,ViewedAt=_now}; message.MessageViews=[new(){UserId=Guid.NewGuid()},view];
_read.Setup(x=>x.ReadMessageAsync(_user,message.Id)).ReturnsAsync(message);
var result=await _hub.Read(new(){MessageId=message.Id});
Assert.That(result.Result!.ViewId,Is.EqualTo(view.Id)); Assert.That(result.Result.ReaderId,Is.EqualTo(_user));
_notifier.Verify(x=>x.NotifyMessageWasReadAsync(result.Result!),Times.Once);
}
[Test]
public async Task ReadFailureDoesNotNotify()
{
_read.Setup(x=>x.ReadMessageAsync(_user,It.IsAny<Guid>())).ReturnsAsync(Govor.Domain.Common.Result.Failure<Message>(Error.NotFound("missing","missing")));
Assert.That((await _hub.Read(new())).Status,Is.EqualTo(HubResultStatus.NotFound)); _notifier.VerifyNoOtherCalls();
}
[TestCase(false)] [TestCase(true)]
public async Task ReadChatMapsResultOrFailure(bool failure)
{
var value=new ChatReadResult(_chat,RecipientType.User,_user,_now,null,null,[Guid.NewGuid()],2,3);
_read.Setup(x=>x.ReadChatAsync(_user,_chat,RecipientType.User,null,null)).ReturnsAsync(failure?Govor.Domain.Common.Result.Failure<ChatReadResult>(Error.Forbidden("denied","denied")):value);
var result=await _hub.ReadChat(_chat,new(){RecipientType=RecipientType.User});
Assert.That(result.Status,Is.EqualTo(failure?HubResultStatus.Forbidden:HubResultStatus.Success));
if(failure) _notifier.VerifyNoOtherCalls(); else {Assert.That(result.Result!.ReadCount,Is.EqualTo(2)); Assert.That(result.Result.UnreadCount,Is.EqualTo(3)); _notifier.Verify(x=>x.NotifyChatReadAsync(result.Result!),Times.Once);}
}
[TestCase(RemoveMessageRequestType.HideForMe,false)] [TestCase(RemoveMessageRequestType.ForceRemove,true)] [TestCase((RemoveMessageRequestType)99,false)]
public async Task RemovalMapsScopeAndNotifies(RemoveMessageRequestType type,bool force)
{
var message=Message();
_remove.Setup(x=>x.DeleteMessageAsync(It.IsAny<DeleteMessage>())).ReturnsAsync(message);
var result=await _hub.Remove(new(){MessageId=message.Id,RequestType=type});
Assert.That(result.Status,Is.EqualTo(HubResultStatus.Success));
_remove.Verify(x=>x.DeleteMessageAsync(new DeleteMessage(_user,message.Id,force)),Times.Once);
_notifier.Verify(x=>x.NotifyMessageRemovedAsync(result.Result!),Times.Once);
}
[Test]
public async Task RemovalFailureDoesNotNotify()
{
_remove.Setup(x=>x.DeleteMessageAsync(It.IsAny<DeleteMessage>())).ReturnsAsync(Govor.Domain.Common.Result.Failure<Message>(Error.Forbidden("denied","denied")));
Assert.That((await _hub.Remove(new())).Status,Is.EqualTo(HubResultStatus.Forbidden)); _notifier.VerifyNoOtherCalls();
}
[TestCase(false)] [TestCase(true)]
public async Task EditSuccessUsesClockAndPreservesRouting(bool noOriginal)
{
var message=Message(); message.ReplyToMessageId=Guid.NewGuid();
_edit.Setup(x=>x.EditMessageAsync(It.IsAny<EditMessage>())).ReturnsAsync(new EditMessageResult(true,null,noOriginal?null:message));
var result=await _hub.Edit(new(){MessageId=message.Id,NewEncryptedContent="new cipher"});
if(noOriginal){Assert.That(result.Status,Is.EqualTo(HubResultStatus.BadRequest)); _notifier.VerifyNoOtherCalls();return;}
Assert.That(result.Result!.ReplyToMessageId,Is.EqualTo(message.ReplyToMessageId)); Assert.That(result.Result.EditedAt,Is.EqualTo(_now));
_edit.Verify(x=>x.EditMessageAsync(new EditMessage(_user,message.Id,"new cipher",_now)),Times.Once);
_notifier.Verify(x=>x.NotifyMessageEditedAsync(result.Result!),Times.Once);
}
[TestCase(false,false)] [TestCase(true,false)] [TestCase(true,true)]
public async Task ReactionsNotifyOnlyOnChange(bool changed,bool remove)
{
var message=Guid.NewGuid(); Guid? reaction=remove?null:Guid.NewGuid();
var state=new MessageReactionState(message,_chat,RecipientType.User,1,_user,null,[],changed);
_reactions.Setup(x=>x.SetAsync(_user,message,reaction)).ReturnsAsync(state);
var mapped=new MessageReactionsChangedResponse(); _mapper.Setup(x=>x.Map<MessageReactionsChangedResponse>(state)).Returns(mapped);
var result=remove?await _hub.RemoveReaction(message):await _hub.React(message,new(){ReactionId=reaction!.Value});
Assert.That(result.Result,Is.SameAs(mapped));
_notifier.Verify(x=>x.NotifyMessageReactionsChangedAsync(mapped),changed?Times.Once():Times.Never());
}
[Test]
public async Task ReactionFailureDoesNotNotify()
{
_reactions.Setup(x=>x.SetAsync(_user,It.IsAny<Guid>(),It.IsAny<Guid?>())).ReturnsAsync(Govor.Domain.Common.Result.Failure<MessageReactionState>(Error.Forbidden("denied","denied")));
Assert.That((await _hub.RemoveReaction(Guid.NewGuid())).Status,Is.EqualTo(HubResultStatus.Forbidden)); _notifier.VerifyNoOtherCalls();
}
[Test]
public async Task NullRequestsAreRejected()
{
Assert.That((await _hub.Read(null!)).Status,Is.EqualTo(HubResultStatus.BadRequest));
Assert.That((await _hub.ReadChat(_chat,null!)).Status,Is.EqualTo(HubResultStatus.BadRequest));
Assert.That((await _hub.Remove(null!)).Status,Is.EqualTo(HubResultStatus.BadRequest));
Assert.That((await _hub.Edit(null!)).Status,Is.EqualTo(HubResultStatus.BadRequest));
Assert.That((await _hub.React(Guid.NewGuid(),null!)).Status,Is.EqualTo(HubResultStatus.BadRequest));
_notifier.VerifyNoOtherCalls();
}
}
@@ -0,0 +1,40 @@
using AutoMapper;
using Govor.API.Common.SignalR.Helpers;
using Govor.API.Hubs;
using Govor.Application.Friends;
using Govor.Contracts.Responses.SignalR;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.API.Tests.Unit.Hubs;
[TestFixture]
public class FriendsHubBoundaryTests
{
[TestCase(false,false)] [TestCase(false,true)] [TestCase(true,false)] [TestCase(true,true)]
public async Task LifecycleHandlesMissingUserAndDisconnectErrors(bool invalid,bool error)
{
var id=invalid?Guid.Empty:Guid.NewGuid();var accessor=new Mock<IHubUserAccessor>();accessor.Setup(x=>x.GetUserId(It.IsAny<HubCallerContext>(),It.IsAny<bool>())).Returns(id);
var context=new Mock<HubCallerContext>();context.SetupGet(x=>x.ConnectionId).Returns("connection");var groups=new Mock<IGroupManager>();
using var hub=new FriendsHub(NullLogger<FriendsHub>.Instance,Mock.Of<IFriendRequestCommandService>(),accessor.Object,Mock.Of<IMapper>()){Context=context.Object,Groups=groups.Object};
await hub.OnConnectedAsync();await hub.OnDisconnectedAsync(error?new Exception("disconnect"):null);
context.Verify(x=>x.Abort(),invalid?Times.Once():Times.Never());
groups.Verify(x=>x.AddToGroupAsync("connection",id.ToString(),default),invalid?Times.Never():Times.Once());
groups.Verify(x=>x.RemoveFromGroupAsync("connection",id.ToString(),default),invalid?Times.Never():Times.Once());
}
[TestCase(0)] [TestCase(1)] [TestCase(2)] public async Task FailedFriendCommandsDoNotNotify(int operation)
{
var commands=new Mock<IFriendRequestCommandService>();var id=Guid.NewGuid();
commands.Setup(x=>x.SendAsync(It.IsAny<Guid>(),id)).ReturnsAsync(Result.Failure<Friendship>(Error.Forbidden("denied","denied")));
commands.Setup(x=>x.AcceptAsync(id,It.IsAny<Guid>())).ReturnsAsync(Result.Failure<Friendship>(Error.Forbidden("denied","denied")));
commands.Setup(x=>x.RejectAsync(id,It.IsAny<Guid>())).ReturnsAsync(Result.Failure<Friendship>(Error.Forbidden("denied","denied")));
var clients=new Mock<IHubCallerClients>(MockBehavior.Strict);
using var hub=new FriendsHub(NullLogger<FriendsHub>.Instance,commands.Object,Mock.Of<IHubUserAccessor>(),Mock.Of<IMapper>()){Clients=clients.Object};
var result=operation switch{0=>await hub.SendRequest(id),1=>await hub.AcceptRequest(id),_=>await hub.RejectRequest(id)};
Assert.That(result.Status,Is.EqualTo(operation==0?HubResultStatus.ServerError:HubResultStatus.BadRequest));clients.VerifyNoOtherCalls();
}
}
@@ -3,8 +3,6 @@ using AutoMapper;
using Govor.API.Common.SignalR.Helpers; using Govor.API.Common.SignalR.Helpers;
using Govor.API.Hubs; using Govor.API.Hubs;
using Govor.Application.Exceptions.FriendsService; using Govor.Application.Exceptions.FriendsService;
using Govor.Application.Interfaces.Friends;
using Govor.Application.Interfaces.Infrastructure.Extensions;
using Govor.Contracts.DTOs; using Govor.Contracts.DTOs;
using Govor.Contracts.Responses.SignalR; using Govor.Contracts.Responses.SignalR;
using Govor.Domain.Models; using Govor.Domain.Models;
@@ -12,7 +10,7 @@ using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Moq; using Moq;
namespace Govor.API.Tests.IntegrationTests.Hubs; namespace Govor.API.Tests.Unit.Hubs;
[TestFixture] [TestFixture]
public class FriendsHubTests public class FriendsHubTests
@@ -24,7 +22,7 @@ public class FriendsHubTests
private Mock<ILogger<FriendsHub>> _loggerMock = null!; private Mock<ILogger<FriendsHub>> _loggerMock = null!;
private Mock<IMapper> _mapperMock = null!; private Mock<IMapper> _mapperMock = null!;
private FriendsHub _hub = null!; private FriendsHub _hub = null!;
private Fixture _fixture; private Fixture _fixture = null!;
private readonly Guid _userId = Guid.NewGuid(); private readonly Guid _userId = Guid.NewGuid();
private readonly Guid _targetUserId = Guid.NewGuid(); private readonly Guid _targetUserId = Guid.NewGuid();
@@ -10,9 +10,8 @@ namespace Govor.API.Tests.Common.SignalR.Helpers;
[TestOf(typeof(HubUserAccessor))] [TestOf(typeof(HubUserAccessor))]
public class HubUserAccessorTests public class HubUserAccessorTests
{ {
private HubUserAccessor _accessor; private HubUserAccessor _accessor = null!;
private Mock<ILogger<HubUserAccessor>> _loggerMock; private Mock<ILogger<HubUserAccessor>> _loggerMock = null!;
[SetUp] [SetUp]
public void SetUp() public void SetUp()
{ {
@@ -1,12 +1,11 @@
using Govor.API.Hubs.Infrastructure; using Govor.API.Hubs.Infrastructure;
namespace Govor.API.Tests.IntegrationTests.Hubs.Infrastructure; namespace Govor.API.Tests.Unit.Hubs.Infrastructure;
[TestFixture] [TestFixture]
public class ConnectionStoreTests public class ConnectionStoreTests
{ {
private ConnectionStore _store; private ConnectionStore _store = null!;
[SetUp] [SetUp]
public void Setup() public void Setup()
{ {
@@ -1,22 +1,19 @@
using Govor.API.Hubs; using Govor.API.Hubs;
using Govor.API.Hubs.Infrastructure; using Govor.API.Hubs.Infrastructure;
using Govor.Application.Infrastructure.Extensions; using Govor.Application.Infrastructure.Extensions;
using Govor.Application.Interfaces;
using Govor.Domain.Models; using Govor.Domain.Models;
using Microsoft.AspNetCore.SignalR; using Microsoft.AspNetCore.SignalR;
using Moq; using Moq;
namespace Govor.API.Tests.IntegrationTests.Hubs.Infrastructure; namespace Govor.API.Tests.Unit.Hubs.Infrastructure;
[TestFixture] [TestFixture]
public class PrivateChatGroupManagerTests public class PrivateChatGroupManagerTests
{ {
private Mock<IConnectionStore> _connectionStoreMock; private Mock<IConnectionStore> _connectionStoreMock = null!;
private Mock<IHubContext<ChatsHub>> _hubContextMock; private Mock<IHubContext<ChatsHub>> _hubContextMock = null!;
private Mock<IGroupManager> _groupsMock; private Mock<IGroupManager> _groupsMock = null!;
private PrivateChatGroupManager _service = null!;
private PrivateChatGroupManager _service;
[SetUp] [SetUp]
public void Setup() public void Setup()
{ {
@@ -0,0 +1,153 @@
using Govor.API.Common.SignalR.Helpers;
using Govor.API.Hubs;
using Govor.Application.Friends;
using Govor.Application.Medias;
using Govor.Application.Profiles;
using Govor.Application.Synching;
using Govor.Application.Users.UserOnlineStatus;
using Govor.Contracts.Responses.SignalR;
using Govor.Domain.Common;
using Govor.Domain.Models.Users;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using SmartRes;
namespace Govor.API.Tests.Unit.Hubs;
[TestFixture]
public class ProfileHubTests
{
private readonly Guid _user = Guid.NewGuid(), _friend = Guid.NewGuid();
private Mock<IFriendshipService> _friends = null!;
private Mock<IProfileService> _profiles = null!;
private Mock<IMediaService> _media = null!;
private Mock<IClientProxy> _proxy = null!;
private Mock<IHubCallerClients> _clients = null!;
private Mock<IGroupManager> _groups = null!;
private ProfileHub _hub = null!;
private List<string> _recipients = null!;
[SetUp]
public void Setup()
{
_friends = new(); _profiles = new(); _media = new(); _proxy = new(); _clients = new(); _groups = new(); _recipients = [];
var accessor = new Mock<IHubUserAccessor>(); accessor.Setup(x => x.GetUserId(It.IsAny<HubCallerContext>(), It.IsAny<bool>())).Returns(_user);
var sync = new Mock<ISynchingService>(); sync.Setup(x => x.NormalizeNewlines(It.IsAny<string>())).Returns((string s) => s.Replace("\r\n", "\n"));
_clients.Setup(x => x.Groups(It.IsAny<IReadOnlyList<string>>())).Callback<IReadOnlyList<string>>(ids => _recipients.AddRange(ids)).Returns(_proxy.Object);
var context = new Mock<HubCallerContext>(); context.SetupGet(x => x.ConnectionId).Returns("connection");
_friends.Setup(x => x.GetFriendsAsync(_user)).ReturnsAsync([new() {Id = _friend}, new() {Id = Guid.Empty}]);
_friends.Setup(x => x.GetPotentialFriendsAsync(_user)).ReturnsAsync([new() {Id = _friend}, new() {Id = Guid.Empty}]);
_profiles.Setup(x => x.SetDescription(It.IsAny<string>(), _user)).ReturnsAsync(SmartRes.Unit.Value);
_profiles.Setup(x => x.SetNewIcon(_user, It.IsAny<Guid>())).ReturnsAsync(SmartRes.Unit.Value);
_media.Setup(x => x.HasMediaAsync(It.IsAny<Guid>())).ReturnsAsync(true);
_hub = new(_friends.Object, _profiles.Object, accessor.Object, sync.Object, _media.Object, NullLogger<ProfileHub>.Instance) { Clients = _clients.Object, Context = context.Object, Groups = _groups.Object };
}
[TearDown] public void TearDown() => _hub.Dispose();
[TestCase(null)] [TestCase("")]
public async Task DescriptionNullIsRejectedAndEmptyIsAllowed(string? description)
{
var result = await _hub.SetDescription(description);
Assert.That(result.Status, Is.EqualTo(description is null ? HubResultStatus.BadRequest : HubResultStatus.Success));
if (description is null) _profiles.VerifyNoOtherCalls();
}
[TestCase(500, HubResultStatus.Success)] [TestCase(501, HubResultStatus.BadRequest)]
public async Task DescriptionLengthBoundary(int size, HubResultStatus expected) => Assert.That((await _hub.SetDescription(new string('a',size))).Status, Is.EqualTo(expected));
[Test]
public async Task DescriptionNormalizesAndNotifiesDistinctNonemptyRecipients()
{
var result = await _hub.SetDescription("one\r\ntwo");
Assert.That(result.Status, Is.EqualTo(HubResultStatus.Success));
_profiles.Verify(x => x.SetDescription("one\ntwo", _user), Times.Once);
Assert.That(_recipients, Is.EquivalentTo(new[] {$"user:{_user}", $"user:{_friend}"}));
_proxy.Verify(x => x.SendCoreAsync("DescriptionUpdated", It.Is<object?[]>(args => args.Length == 1), default), Times.Once);
}
[TestCase(false)] [TestCase(true)]
public async Task ProfileServiceFailuresDoNotNotify(bool avatar)
{
_profiles.Setup(x => x.SetDescription(It.IsAny<string>(), _user)).ReturnsAsync(Result.Failure<SmartRes.Unit>(Error.Forbidden("denied", "denied")));
_profiles.Setup(x => x.SetNewIcon(_user, It.IsAny<Guid>())).ReturnsAsync(Result.Failure<SmartRes.Unit>(Error.Forbidden("denied", "denied")));
var result = avatar ? await _hub.SetAvatar(Guid.NewGuid()) : await _hub.SetDescription("hello");
Assert.That(result.Status, Is.EqualTo(HubResultStatus.Forbidden)); _proxy.VerifyNoOtherCalls();
}
[TestCase(false)] [TestCase(true)]
public async Task ProfileServiceExceptionsReturnServerError(bool avatar)
{
_profiles.Setup(x => x.SetDescription(It.IsAny<string>(), _user)).ThrowsAsync(new Exception("failure"));
_profiles.Setup(x => x.SetNewIcon(_user, It.IsAny<Guid>())).ThrowsAsync(new Exception("failure"));
var result = avatar ? await _hub.SetAvatar(Guid.NewGuid()) : await _hub.SetDescription("hello");
Assert.That(result.Status, Is.EqualTo(HubResultStatus.ServerError)); _proxy.VerifyNoOtherCalls();
}
[TestCase(true)] [TestCase(false)]
public async Task InvalidAvatarNeverChangesProfile(bool empty)
{
_media.Setup(x => x.HasMediaAsync(It.IsAny<Guid>())).ReturnsAsync(false);
Assert.That((await _hub.SetAvatar(empty ? Guid.Empty : Guid.NewGuid())).Status, Is.EqualTo(HubResultStatus.BadRequest));
_profiles.VerifyNoOtherCalls();
}
[Test]
public async Task AvatarPersistsAndNotifies()
{
var icon = Guid.NewGuid();
Assert.That((await _hub.SetAvatar(icon)).Status, Is.EqualTo(HubResultStatus.Success));
_profiles.Verify(x => x.SetNewIcon(_user, icon), Times.Once);
_proxy.Verify(x => x.SendCoreAsync("AvatarUpdated", It.IsAny<object?[]>(), default), Times.Once);
}
[TestCase(false)] [TestCase(true)]
public async Task NotificationFailuresDoNotUndoPersistedProfile(bool deliveryFailure)
{
if (deliveryFailure) _proxy.Setup(x => x.SendCoreAsync(It.IsAny<string>(), It.IsAny<object?[]>(), default)).ThrowsAsync(new Exception("transport"));
else {
_friends.Setup(x => x.GetFriendsAsync(_user)).ThrowsAsync(new Exception("friends"));
_friends.Setup(x => x.GetPotentialFriendsAsync(_user)).ThrowsAsync(new Exception("potential"));
}
Assert.That((await _hub.SetDescription("hello")).Status, Is.EqualTo(HubResultStatus.Success));
if (!deliveryFailure) Assert.That(_recipients, Is.EqualTo(new[] { $"user:{_user}" }));
}
[TestCase(false)] [TestCase(true)]
public async Task LifecycleMaintainsUserGroup(bool error)
{
await _hub.OnConnectedAsync(); await _hub.OnDisconnectedAsync(error ? new Exception("disconnect") : null);
_groups.Verify(x => x.AddToGroupAsync("connection", $"user:{_user}", default), Times.Once);
_groups.Verify(x => x.RemoveFromGroupAsync("connection", $"user:{_user}", default), Times.Once);
}
}
[TestFixture]
public class PresenceHubTests
{
[TestCase(true, true)] [TestCase(true, false)] [TestCase(false, true)] [TestCase(false, false)]
public async Task OnlyFirstConnectionAndLastDisconnectionBroadcast(bool first, bool last)
{
var user = Guid.NewGuid(); var friend = Guid.NewGuid();
var accessor = new Mock<IHubUserAccessor>(); accessor.Setup(x => x.GetUserId(It.IsAny<HubCallerContext>(), It.IsAny<bool>())).Returns(user);
var store = new Mock<IOnlineUserStore>(); store.Setup(x => x.AddConnection(user,"connection")).Returns(first); store.Setup(x => x.RemoveConnection(user,"connection")).Returns(last);
var scope = new Mock<IUserNotificationScopeService>(); scope.Setup(x => x.GetNotifiedUsers(user)).ReturnsAsync([friend]);
var proxy = new Mock<IClientProxy>(); var clients = new Mock<IHubCallerClients>(); clients.Setup(x => x.Groups(It.Is<IReadOnlyList<string>>(ids => ids.SequenceEqual(new[] {friend.ToString()})))).Returns(proxy.Object);
var groups = new Mock<IGroupManager>(); var context = new Mock<HubCallerContext>(); context.SetupGet(x => x.ConnectionId).Returns("connection");
using var hub = new PresenceHub(NullLogger<PresenceHub>.Instance,scope.Object,store.Object,accessor.Object) { Context = context.Object, Clients = clients.Object, Groups = groups.Object };
await hub.OnConnectedAsync(); await hub.OnDisconnectedAsync(null!);
proxy.Verify(x => x.SendCoreAsync("UserOnline",It.Is<object?[]>(args => Equals(args[0],user)),default),first ? Times.Once() : Times.Never());
proxy.Verify(x => x.SendCoreAsync("UserOffline",It.Is<object?[]>(args => Equals(args[0],user)),default),last ? Times.Once() : Times.Never());
groups.Verify(x => x.AddToGroupAsync("connection",user.ToString(),default),Times.Once);
groups.Verify(x => x.RemoveFromGroupAsync("connection",user.ToString(),default),Times.Once);
}
[Test]
public async Task InvalidUserAbortsWithoutStoreOrNotifications()
{
var accessor = new Mock<IHubUserAccessor>(); var context = new Mock<HubCallerContext>();
var store = new Mock<IOnlineUserStore>(MockBehavior.Strict); var scope = new Mock<IUserNotificationScopeService>(MockBehavior.Strict);
using var hub = new PresenceHub(NullLogger<PresenceHub>.Instance,scope.Object,store.Object,accessor.Object) {Context=context.Object};
await hub.OnConnectedAsync(); await hub.OnDisconnectedAsync(null!);
context.Verify(x => x.Abort(),Times.Once); store.VerifyNoOtherCalls(); scope.VerifyNoOtherCalls();
}
}

Some files were not shown because too many files have changed in this diff Show More