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
@@ -0,0 +1,10 @@
global using Govor.Application.Authentication;
global using Govor.Application.Authentication.JWT;
global using Govor.Application.Friends;
global using Govor.Application.Infrastructure.Extensions;
global using Govor.Application.Infrastructure.Validators;
global using Govor.Application.Medias;
global using Govor.Application.Storage;
global using Govor.Application.Users.UserOnlineStatus;
global using Govor.Application.Users.UserSessions;
global using Govor.Domain;
@@ -0,0 +1,6 @@
<Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<ProjectReference Include="../../Govor.Application/Govor.Application.csproj" />
<PackageReference Include="AutoFixture" Version="5.0.0-preview0012" />
</ItemGroup>
</Project>
@@ -0,0 +1,105 @@
using Govor.Application.Infrastructure.AdminsStuff;
using Govor.Application.Infrastructure.Common;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Application.Tests.Integration.Administration;
[TestFixture]
public class AdministrationTests
{
private TestDatabase _db = null!;
private UsersService _users = null!;
private InvitationGetter _invitations = null!;
private Mock<IPasswordHasher> _hasher = null!;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
_hasher = new Mock<IPasswordHasher>();
_hasher.Setup(h => h.Hash("new password")).Returns("new hash");
_users = new(_db.Context, _hasher.Object);
_invitations = new(NullLogger<InvitationGetter>.Instance, _db.Context);
}
[TearDown] public void TearDown() => _db.Dispose();
[Test]
public async Task PasswordResetRevokesOnlyTargetsSessionsAndPushTokens()
{
var own = new UserSession { UserId = _db.Alice, RefreshTokenHash = "alice" };
var bob = new UserSession { UserId = _db.Bob, RefreshTokenHash = "bob" };
_db.Context.UserSessions.AddRange(own, bob);
_db.Context.UserPushTokens.AddRange(
new UserPushToken { UserId = _db.Alice, UserSessionId = own.Id, Token = "alice", Platform = "android" },
new UserPushToken { UserId = _db.Bob, UserSessionId = bob.Id, Token = "bob", Platform = "android" });
await _db.Context.SaveChangesAsync();
await _users.SetPasswordAsync(_db.Alice, "new password");
_db.Context.ChangeTracker.Clear();
Assert.That((await _users.GetUserById(_db.Alice)).PasswordHash, Is.EqualTo("new hash"));
Assert.That((await _db.Context.UserSessions.SingleAsync(s => s.Id == own.Id)).IsRevoked, Is.True);
Assert.That((await _db.Context.UserSessions.SingleAsync(s => s.Id == bob.Id)).IsRevoked, Is.False);
Assert.That((await _db.Context.UserPushTokens.SingleAsync(t => t.UserId == _db.Alice)).IsActive, Is.False);
Assert.That((await _db.Context.UserPushTokens.SingleAsync(t => t.UserId == _db.Bob)).IsActive, Is.True);
}
[Test]
public async Task MissingUserDoesNotHashOrChangeAccounts()
{
var missing = Guid.NewGuid();
Assert.That(await _users.GetUserById(missing), Is.Null);
await _users.SetPasswordAsync(missing, "new password");
_hasher.VerifyNoOtherCalls();
Assert.That(await _db.Context.Users.CountAsync(), Is.EqualTo(3));
}
[Test]
public async Task UserListIsBoundedAndUntracked()
{
var invite = await _db.Context.Invitations.SingleAsync();
_db.Context.Users.AddRange(Enumerable.Range(0, 60).Select(i => new User {
Id = Guid.NewGuid(), Username = "user-" + i, PasswordHash = "hash", InviteId = invite.Id, Description = "" }));
await _db.Context.SaveChangesAsync();
_db.Context.ChangeTracker.Clear();
Assert.That(await _users.GetAllUsersAsync(), Has.Count.EqualTo(50));
Assert.That(_db.Context.ChangeTracker.Entries(), Is.Empty);
}
[Test]
public async Task InvitationListFiltersInactiveButLookupCanReadIt()
{
var inactive = new Invitation { Id = Guid.NewGuid(), Code = "inactive", Description = "", IsActive = false };
_db.Context.Invitations.Add(inactive);
await _db.Context.SaveChangesAsync();
_db.Context.ChangeTracker.Clear();
Assert.That((await _invitations.GetAllAsync()).Any(i => i.Id == inactive.Id), Is.False);
Assert.That((await _invitations.FindByIdAsync(inactive.Id)).Value.Code, Is.EqualTo("inactive"));
Assert.That((await _invitations.FindByIdAsync(Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That(_db.Context.ChangeTracker.Entries(), Is.Empty);
}
[Test]
public async Task RolesDefaultToUserAndAdminRoleComesFromInvitation()
{
var clock = Mock.Of<INowDateTimeProvider>();
var invites = new InvitesService(_db.Context, clock);
var user = await _users.GetUserById(_db.Alice);
Assert.That(await invites.GetRoleNameAsync(Guid.NewGuid()), Is.EqualTo("User"));
Assert.That(await invites.GetRoleNameAsync(user), Is.EqualTo("User"));
var invitation = await _db.Context.Invitations.SingleAsync();
invitation.IsAdmin = true;
await _db.Context.SaveChangesAsync();
Assert.That(await invites.GetRoleNameAsync(user), Is.EqualTo("Admin"));
}
[Test]
public async Task UnknownInvitationReturnsNotFound()
{
var service = new InvitesService(_db.Context, Mock.Of<INowDateTimeProvider>());
Assert.That((await service.ValidateAsync("unknown")).Error.Type, Is.EqualTo(ErrorType.NotFound));
}
}
@@ -0,0 +1,102 @@
using Govor.Application.Authentication;
using Govor.Application.Infrastructure.Common;
using Govor.Application.Infrastructure.Validators;
using Govor.Application.Users;
using Govor.Domain.Common;
using Microsoft.EntityFrameworkCore;
using Moq;
namespace Govor.Application.Tests.Authentication;
[TestFixture]
public class AuthServiceTests
{
private TestDatabase _db = null!;
private AuthService _service = null!;
private Mock<IPasswordHasher> _hasher = null!;
private readonly DateTime _now = new(2026, 10, 24, 0, 0, 0, DateTimeKind.Utc);
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
_hasher = new Mock<IPasswordHasher>();
_hasher.Setup(h => h.Hash(It.IsAny<string>())).Returns("hashed-password");
_hasher.Setup(h => h.Verify("correct", It.IsAny<string>())).Returns(true);
var validator = new Mock<IUsernameValidator>();
validator.Setup(v => v.Validate(It.IsAny<string>())).Returns(Result.Success());
var clock = new Mock<INowDateTimeProvider>();
clock.SetupGet(c => c.Now).Returns(_now);
_service = new AuthService(_db.Context, new UserNameExistValidator(_db.Context),
_hasher.Object, validator.Object, clock.Object);
}
[TearDown] public void TearDown() => _db.Dispose();
[TestCase(false)]
[TestCase(true)]
public async Task RegistrationPersistsAccountReservesInvitationAndAssignsRole(bool admin)
{
var invite = await _db.Context.Invitations.SingleAsync();
invite.IsAdmin = admin;
await _db.Context.SaveChangesAsync();
var result = await _service.RegistrationAsync("Новый", "secret", invite);
Assert.That(result.IsSuccess, Is.True);
_db.Context.ChangeTracker.Clear();
var user = await _db.Context.Users.SingleAsync(u => u.Id == result.Value.Id);
Assert.Multiple(() =>
{
Assert.That(user.Username, Is.EqualTo("Новый"));
Assert.That(user.PasswordHash, Is.EqualTo("hashed-password"));
Assert.That(user.CreatedOn, Is.EqualTo(DateOnly.FromDateTime(_now)));
Assert.That(user.InviteId, Is.EqualTo(invite.Id));
});
Assert.That(await _db.Context.Admins.AnyAsync(a => a.UserId == user.Id), Is.EqualTo(admin));
Assert.That((await _db.Context.Invitations.SingleAsync()).Participants, Is.EqualTo(1));
}
[Test]
public async Task ExistingUsernameReturnsConflictWithoutConsumingInvitation()
{
var user = await _db.Context.Users.FirstAsync();
var invite = await _db.Context.Invitations.SingleAsync();
var result = await _service.RegistrationAsync(user.Username, "secret", invite);
Assert.That(result.Error.Type, Is.EqualTo(ErrorType.Conflict));
Assert.That((await _db.Context.Invitations.AsNoTracking().SingleAsync()).Participants, Is.Zero);
_hasher.Verify(h => h.Hash(It.IsAny<string>()), Times.Never);
}
[TestCase("expired")]
[TestCase("full")]
[TestCase("inactive")]
public async Task UnavailableInvitationDoesNotCreateAccount(string reason)
{
var invite = await _db.Context.Invitations.SingleAsync();
if (reason == "expired") invite.EndDate = _now;
if (reason == "full") invite.MaxParticipants = 3;
if (reason == "inactive") invite.IsActive = false;
await _db.Context.SaveChangesAsync();
var result = await _service.RegistrationAsync("Новый", "secret", invite);
Assert.That(result.Error.Code, Is.EqualTo("Auth.InvitationUnavailable"));
Assert.That(await _db.Context.Users.CountAsync(), Is.EqualTo(3));
}
[TestCase("correct", true)]
[TestCase("wrong", false)]
public async Task LoginVerifiesStoredPassword(string password, bool success)
{
var user = await _db.Context.Users.FirstAsync();
var result = await _service.LoginAsync(user.Username, password);
Assert.That(result.IsSuccess, Is.EqualTo(success));
_hasher.Verify(h => h.Verify(password, user.PasswordHash), Times.Once);
if (success) Assert.That(result.Value.Id, Is.EqualTo(user.Id));
}
[Test]
public async Task MissingUserReturnsNotFound()
{
var result = await _service.LoginAsync("missing", "secret");
Assert.That(result.Error.Type, Is.EqualTo(ErrorType.NotFound));
_hasher.Verify(h => h.Verify(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
}
}
@@ -0,0 +1,49 @@
using Govor.Application.Infrastructure.Common;
using Govor.Application.Users;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Microsoft.EntityFrameworkCore;
using Moq;
namespace Govor.Application.Tests.Integration.Authentication;
[TestFixture]
public class AuthenticationFailureTests
{
[Test]
public async Task InvalidUsernameStopsRegistrationBeforePasswordHashOrDatabaseWrite()
{
using var db = new TestDatabase();
var error = Error.Validation("Username.Invalid", "invalid username");
var validator = new Mock<IUsernameValidator>();
validator.Setup(v => v.Validate("bad")).Returns(Result.Failure(error));
var hasher = new Mock<IPasswordHasher>(MockBehavior.Strict);
var exists = new Mock<IUserNameExistValidator>(MockBehavior.Strict);
var service = new AuthService(db.Context, exists.Object, hasher.Object, validator.Object, Mock.Of<INowDateTimeProvider>());
var result = await service.RegistrationAsync("bad", "password", await db.Context.Invitations.SingleAsync());
Assert.That(result.Error, Is.SameAs(error));
Assert.That(await db.Context.Users.CountAsync(), Is.EqualTo(3));
hasher.VerifyNoOtherCalls();
exists.VerifyNoOtherCalls();
}
[Test]
public async Task NonChannelRequiredGroupRejectsRegistrationWithoutConsumingInvitation()
{
using var db = new TestDatabase();
var group = new ChatGroup { Id = Guid.NewGuid(), Name = "not a channel", Description = "" };
db.Context.ChatGroups.Add(group);
(await db.Context.ServerCommunitySettings.SingleAsync()).RequiredChannelId = group.Id;
await db.Context.SaveChangesAsync();
var validator = Mock.Of<IUsernameValidator>(v => v.Validate("Новый") == Result.Success());
var hasher = Mock.Of<IPasswordHasher>(h => h.Hash("password") == "hash");
var service = new AuthService(db.Context, new UserNameExistValidator(db.Context), hasher, validator,
Mock.Of<INowDateTimeProvider>(c => c.Now == DateTime.UtcNow.Date));
var invitation = await db.Context.Invitations.SingleAsync();
var result = await service.RegistrationAsync("Новый", "password", invitation);
Assert.That(result.Error.Code, Is.EqualTo("Auth.RequiredChannelUnavailable"));
Assert.That(await db.Context.Users.CountAsync(), Is.EqualTo(3));
Assert.That((await db.Context.Invitations.AsNoTracking().SingleAsync()).Participants, Is.Zero);
}
}
@@ -0,0 +1,80 @@
using Govor.Application.Messages;
using Govor.Application.PrivateUserChats;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Microsoft.EntityFrameworkCore;
namespace Govor.Application.Tests.Integration.Friends;
[TestFixture]
public class FriendsBlockServiceTests
{
private TestDatabase _db = null!;
private FriendsBlockService _service = null!;
[SetUp] public void SetUp() { _db = new TestDatabase(); _service = new(_db.Context); }
[TearDown] public void TearDown() => _db.Dispose();
[TestCase(false)]
[TestCase(true)]
public async Task BlockCreatesOrUpdatesRelationshipAndPreventsNewMessages(bool existing)
{
Guid? original = null;
if (existing)
{
var friend = new Friendship { Id = Guid.NewGuid(), RequesterId = _db.Bob, AddresseeId = _db.Alice, Status = FriendshipStatus.Accepted };
_db.Context.Friendships.Add(friend);
await _db.Context.SaveChangesAsync();
original = friend.Id;
}
await _service.BlockFriendRequestAsync(_db.Bob, _db.Alice);
await _service.BlockFriendRequestAsync(_db.Bob, _db.Alice);
_db.Context.ChangeTracker.Clear();
var block = await _db.Context.Friendships.SingleAsync();
Assert.That(block.RequesterId, Is.EqualTo(_db.Alice));
Assert.That(block.AddresseeId, Is.EqualTo(_db.Bob));
Assert.That(block.Status, Is.EqualTo(FriendshipStatus.Blocked));
if (original.HasValue) Assert.That(block.Id, Is.EqualTo(original.Value));
var sender = new MessageSendingService(_db.Context, Microsoft.Extensions.Logging.Abstractions.NullLogger<MessageSendingService>.Instance);
var sent = await sender.SendMessageAsync(new("hello", null, _db.ChatId, RecipientType.User, _db.Bob, DateTime.UtcNow, []));
Assert.That(sent.IsSuccess, Is.False);
Assert.That(sent.Exception, Is.TypeOf<UnauthorizedAccessException>());
var requests = new FriendRequestCommandService(_db.Context, Moq.Mock.Of<IUserPrivateChatsCreator>());
Assert.That((await requests.SendAsync(_db.Bob, _db.Alice)).IsFailure, Is.True);
}
[Test]
public async Task OnlyBlockOwnerCanRemoveOrReplaceBlockAndUnblockAllowsNewRequest()
{
await _service.BlockFriendRequestAsync(_db.Bob, _db.Alice);
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _service.UnblockFriendRequestAsync(_db.Alice, _db.Bob));
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _service.BlockFriendRequestAsync(_db.Alice, _db.Bob));
await _service.UnblockFriendRequestAsync(_db.Bob, _db.Alice);
await _service.UnblockFriendRequestAsync(_db.Bob, _db.Alice);
Assert.That((await _db.Context.Friendships.SingleAsync()).Status, Is.EqualTo(FriendshipStatus.Rejected));
var requests = new FriendRequestCommandService(_db.Context, Moq.Mock.Of<IUserPrivateChatsCreator>());
Assert.That((await requests.SendAsync(_db.Alice, _db.Bob)).IsSuccess, Is.True);
Assert.That((await _db.Context.Friendships.SingleAsync()).Status, Is.EqualTo(FriendshipStatus.Pending));
}
[Test]
public async Task UnblockingMissingOrUnblockedRelationshipDoesNotChangeFriendship()
{
await _service.UnblockFriendRequestAsync(_db.Bob, _db.Alice);
_db.Context.Friendships.Add(new Friendship { Id = Guid.NewGuid(), RequesterId = _db.Alice,
AddresseeId = _db.Bob, Status = FriendshipStatus.Accepted });
await _db.Context.SaveChangesAsync();
await _service.UnblockFriendRequestAsync(_db.Bob, _db.Alice);
Assert.That((await _db.Context.Friendships.SingleAsync()).Status, Is.EqualTo(FriendshipStatus.Accepted));
}
[Test]
public void InvalidOrMissingUsersCannotBeBlocked()
{
Assert.ThrowsAsync<ArgumentException>(() => _service.BlockFriendRequestAsync(_db.Alice, _db.Alice));
Assert.ThrowsAsync<ArgumentException>(() => _service.BlockFriendRequestAsync(Guid.Empty, _db.Alice));
Assert.ThrowsAsync<ArgumentException>(() => _service.UnblockFriendRequestAsync(_db.Alice, Guid.Empty));
Assert.ThrowsAsync<ArgumentException>(() => _service.UnblockFriendRequestAsync(_db.Alice, _db.Alice));
Assert.ThrowsAsync<KeyNotFoundException>(() => _service.BlockFriendRequestAsync(Guid.NewGuid(), _db.Alice));
}
}
@@ -0,0 +1,126 @@
using Govor.Application.Friends;
using Govor.Application.PrivateUserChats;
using Govor.Application.Exceptions.VerifyFriendship;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Application.Tests.Friends;
[TestFixture]
public class FriendshipTests
{
private TestDatabase _db = null!;
private FriendRequestCommandService _commands = null!;
private Mock<IUserPrivateChatsCreator> _chats = null!;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
_chats = new Mock<IUserPrivateChatsCreator>();
_commands = new FriendRequestCommandService(_db.Context, _chats.Object);
}
[TearDown] public void TearDown() => _db.Dispose();
[Test]
public async Task RequestCanBeAcceptedOnlyByAddresseeAndCreatesChat()
{
var sent = await _commands.SendAsync(_db.Alice, _db.Bob);
Assert.That(sent.Value.Status, Is.EqualTo(FriendshipStatus.Pending));
Assert.That((await _commands.AcceptAsync(sent.Value.Id, _db.Outsider)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _commands.AcceptAsync(sent.Value.Id, _db.Bob)).Value.Status, Is.EqualTo(FriendshipStatus.Accepted));
Assert.That((await _commands.AcceptAsync(sent.Value.Id, _db.Bob)).IsFailure, Is.True);
_chats.Verify(c => c.CreateAsync(_db.Bob, _db.Alice), Times.Once);
var verifier = new VerifyFriendship(_db.Context, NullLogger<VerifyFriendship>.Instance);
Assert.That(await verifier.TryVerifyAsync(_db.Alice, _db.Bob), Is.True);
Assert.That(await verifier.TryVerifyAsync(_db.Bob, _db.Alice), Is.True);
Assert.DoesNotThrowAsync(() => verifier.VerifyAsync(_db.Alice, _db.Bob));
}
[Test]
public async Task DuplicateAndReversePendingRequestsReturnConflict()
{
await _commands.SendAsync(_db.Alice, _db.Bob);
Assert.That((await _commands.SendAsync(_db.Alice, _db.Bob)).Error.Type, Is.EqualTo(ErrorType.Conflict));
Assert.That((await _commands.SendAsync(_db.Bob, _db.Alice)).Error.Type, Is.EqualTo(ErrorType.Conflict));
Assert.That(await _db.Context.Friendships.CountAsync(), Is.EqualTo(1));
}
[Test]
public async Task SelfRequestDoesNotPersist()
{
Assert.That((await _commands.SendAsync(_db.Alice, _db.Alice)).IsFailure, Is.True);
Assert.That(await _db.Context.Friendships.CountAsync(), Is.Zero);
}
[Test]
public async Task RejectedRequestCanBeResentInOtherDirection()
{
var sent = (await _commands.SendAsync(_db.Alice, _db.Bob)).Value;
Assert.That((await _commands.RejectAsync(sent.Id, _db.Alice)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _commands.RejectAsync(sent.Id, _db.Bob)).Value.Status, Is.EqualTo(FriendshipStatus.Rejected));
var resent = (await _commands.SendAsync(_db.Bob, _db.Alice)).Value;
Assert.That(resent.Id, Is.EqualTo(sent.Id));
Assert.That(resent.AddresseeId, Is.EqualTo(_db.Alice));
Assert.That(resent.Status, Is.EqualTo(FriendshipStatus.Pending));
_chats.VerifyNoOtherCalls();
}
[Test]
public async Task MissingRequestsReturnNotFound()
{
Assert.That((await _commands.AcceptAsync(Guid.NewGuid(), _db.Bob)).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _commands.RejectAsync(Guid.NewGuid(), _db.Bob)).Error.Type, Is.EqualTo(ErrorType.NotFound));
}
[TestCase(FriendshipStatus.Accepted)]
[TestCase(FriendshipStatus.Blocked)]
public async Task EstablishedOrBlockedFriendshipCannotBeRequestedOrRejected(FriendshipStatus status)
{
var sent = (await _commands.SendAsync(_db.Alice, _db.Bob)).Value;
sent.Status = status;
await _db.Context.SaveChangesAsync();
Assert.That((await _commands.SendAsync(_db.Bob, _db.Alice)).Error.Type, Is.EqualTo(ErrorType.Conflict));
Assert.That((await _commands.RejectAsync(sent.Id, _db.Bob)).Error.Type, Is.EqualTo(ErrorType.Conflict));
}
[Test]
public async Task QueriesFilterStatusAndDirection()
{
var sent = (await _commands.SendAsync(_db.Alice, _db.Bob)).Value;
var query = new FriendRequestQueryService(_db.Context);
var friends = new FriendshipService(_db.Context);
Assert.That((await query.GetIncomingAsync(_db.Bob)).Select(f => f.Id), Is.EqualTo(new[] { sent.Id }));
Assert.That(await query.GetIncomingAsync(_db.Alice), Is.Empty);
Assert.That((await friends.GetPotentialFriendsAsync(_db.Alice)).Select(u => u.Id), Is.EqualTo(new[] { _db.Bob }));
Assert.That(await friends.GetFriendsAsync(_db.Alice), Is.Empty);
await _commands.AcceptAsync(sent.Id, _db.Bob);
Assert.That(await query.GetIncomingAsync(_db.Bob), Is.Empty);
Assert.That(await query.GetResponsesAsync(_db.Alice), Is.Empty);
Assert.That((await friends.GetFriendsAsync(_db.Alice)).Select(u => u.Id), Is.EqualTo(new[] { _db.Bob }));
Assert.That((await friends.GetFriendsAsync(_db.Bob)).Select(u => u.Id), Is.EqualTo(new[] { _db.Alice }));
}
[Test]
public async Task SearchExcludesCurrentUserAndEmptyQuery()
{
var service = new FriendshipService(_db.Context);
Assert.That(await service.SearchUsersAsync(" ", _db.Alice), Is.Empty);
Assert.That((await service.SearchUsersAsync("-", _db.Alice)).Select(u => u.Id),
Is.EquivalentTo(new[] { _db.Bob, _db.Outsider }));
}
[Test]
public async Task VerifierRejectsMissingOrPendingFriendshipAndEmptyIds()
{
var verifier = new VerifyFriendship(_db.Context, NullLogger<VerifyFriendship>.Instance);
await _commands.SendAsync(_db.Alice, _db.Bob);
Assert.That(await verifier.TryVerifyAsync(_db.Alice, _db.Bob), Is.False);
Assert.That(await verifier.TryVerifyAsync(Guid.Empty, _db.Bob), Is.False);
Assert.ThrowsAsync<FriendshipException>(() => verifier.VerifyAsync(_db.Alice, _db.Bob));
Assert.ThrowsAsync<ArgumentException>(() => verifier.VerifyAsync(Guid.Empty, _db.Bob));
}
}
@@ -0,0 +1,85 @@
using Govor.Application.Groups;
using Govor.Application.Infrastructure.Common;
using Govor.Application.Reactions;
using Govor.Application.Tests.Support;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Reactions;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Application.Tests.Integration.Groups;
[TestFixture]
public class GroupAvatarBoundaryTests
{
private TestDatabase _db = null!;
private Guid _group;
private Mock<IReactionMediaProcessor> _processor = null!;
private Mock<IStorageService> _storage = null!;
private readonly ProcessedReactionMedia _image = new(new byte[] { 1 }, ReactionKind.Image, "image/png", ".png", 10, 10, 0);
private GroupAvatarService Service(GovorDbContext? context = null) => new(context ?? _db.Context,
Mock.Of<INowDateTimeProvider>(c => c.Now == DateTime.UtcNow.Date), _processor.Object, _storage.Object, NullLogger<GroupAvatarService>.Instance);
[SetUp]
public async Task SetUp()
{
_db = new TestDatabase();
_group = Guid.NewGuid();
_db.Context.ChatGroups.Add(new ChatGroup { Id = _group, Name = "group", Description = "", OwnerUserId = _db.Alice });
_db.Context.GroupMemberships.Add(new GroupMembership { Id = Guid.NewGuid(), GroupId = _group, UserId = _db.Alice });
await _db.Context.SaveChangesAsync();
_processor = new Mock<IReactionMediaProcessor>(MockBehavior.Strict);
_storage = new Mock<IStorageService>(MockBehavior.Strict);
}
[TearDown] public void TearDown() => _db.Dispose();
[Test]
public async Task NonOwnerCannotProcessSaveOrRemoveAvatar()
{
Assert.That((await Service().UploadAsync(_db.Bob, _group, new byte[] { 1 })).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await Service().RemoveAsync(_db.Bob, _group)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
_processor.VerifyNoOtherCalls();
_storage.VerifyNoOtherCalls();
}
[Test]
public async Task InvalidAndAnimatedImagesAreRejectedBeforeStorage()
{
var error = Error.Validation("Media.Invalid", "invalid");
_processor.SetupSequence(p => p.ProcessAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(Result.Failure<ProcessedReactionMedia>(error)).ReturnsAsync(_image with { Kind = ReactionKind.Gif });
Assert.That((await Service().UploadAsync(_db.Alice, _group, new byte[] { 1 })).Error, Is.SameAs(error));
Assert.That((await Service().UploadAsync(_db.Alice, _group, new byte[] { 1 })).Error.Code, Is.EqualTo("Group.Avatar.Invalid"));
_storage.VerifyNoOtherCalls();
}
[Test]
public async Task LossOfOwnershipDuringImageProcessingPreventsUpload()
{
_processor.Setup(p => p.ProcessAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>())).Returns(async () =>
{
await _db.Context.ChatGroups.Where(g => g.Id == _group).ExecuteUpdateAsync(s => s.SetProperty(g => g.OwnerUserId, _db.Bob));
return Result.Success(_image);
});
Assert.That((await Service().UploadAsync(_db.Alice, _group, new byte[] { 1 })).Error.Type, Is.EqualTo(ErrorType.Forbidden));
_storage.VerifyNoOtherCalls();
}
[TestCase(false)]
[TestCase(true)]
public async Task FailedMetadataWriteRollsBackAndCleansStoredImage(bool cleanupFails)
{
_processor.Setup(p => p.ProcessAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>())).ReturnsAsync(_image);
_storage.Setup(s => s.SaveAsync(It.IsAny<byte[]>(), It.IsAny<string>())).ReturnsAsync("failed.png");
if (cleanupFails) _storage.Setup(s => s.RemoveAsync("failed.png")).ThrowsAsync(new IOException("cleanup failure"));
else _storage.Setup(s => s.RemoveAsync("failed.png")).Returns(Task.CompletedTask);
using var failed = _db.CreateContext(new FailDatabaseCommand(sql => sql.Contains("INSERT INTO \"MediaFiles\"", StringComparison.Ordinal)));
Assert.ThrowsAsync<DbUpdateException>(() => Service(failed).UploadAsync(_db.Alice, _group, new byte[] { 1 }));
_storage.Verify(s => s.RemoveAsync("failed.png"), Times.Once);
Assert.That(await _db.Context.MediaFiles.CountAsync(), Is.Zero);
Assert.That((await _db.Context.ChatGroups.AsNoTracking().SingleAsync()).ImageId, Is.EqualTo(Guid.Empty));
Assert.That(failed.ChangeTracker.Entries(), Is.Empty);
}
}
@@ -0,0 +1,78 @@
using Govor.Application.Groups;
using Govor.Application.Infrastructure.Common;
using Govor.Domain.Common;
using Microsoft.EntityFrameworkCore;
using Moq;
namespace Govor.Application.Tests.Integration.Groups;
[TestFixture]
public class GroupManagementBoundaryTests
{
private TestDatabase _db = null!;
private GroupManagementService _service = null!;
private Guid _group;
[SetUp]
public async Task SetUp()
{
_db = new TestDatabase();
_service = new(_db.Context, Mock.Of<INowDateTimeProvider>(c => c.Now == DateTime.UtcNow.Date));
_group = (await _service.CreateAsync(_db.Alice, "group", "", false, false)).Value.Group.Id;
await _service.JoinPublicAsync(_db.Bob, _group);
}
[TearDown] public void TearDown() => _db.Dispose();
[TestCase("name")]
[TestCase("description")]
[TestCase("null-description")]
public async Task InvalidGroupProfilesCannotCreateOrUpdate(string kind)
{
var name = kind == "name" ? new string('x', 101) : "group";
var description = kind == "description" ? new string('x', 501) : kind == "null-description" ? null : "";
Assert.That((await _service.CreateAsync(_db.Alice, name, description!, false, false)).IsFailure, Is.True);
Assert.That((await _service.UpdateAsync(_db.Alice, _group, name, description!, false)).IsFailure, Is.True);
Assert.That(await _db.Context.ChatGroups.CountAsync(), Is.EqualTo(1));
}
[Test]
public async Task UnknownActorCannotCreateOrJoinGroups()
{
Assert.That((await _service.CreateAsync(Guid.NewGuid(), "name", "", false, false)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _service.JoinPublicAsync(Guid.NewGuid(), _group)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _service.UpdateAsync(_db.Alice, Guid.NewGuid(), "name", "", false)).Error.Type, Is.EqualTo(ErrorType.NotFound));
}
[Test]
public async Task MembershipAndAdministrationGuardsProtectOwnerAndOutsiders()
{
Assert.That((await _service.MembersAsync(_db.Outsider, _group, false, 0, 20)).IsFailure, Is.True);
Assert.That((await _service.MembersAsync(_db.Bob, _group, true, 0, 20)).IsFailure, Is.True);
Assert.That((await _service.LeaveAsync(_db.Outsider, _group)).IsFailure, Is.True);
Assert.That((await _service.LeaveAsync(_db.Alice, _group)).IsFailure, Is.True);
Assert.That((await _service.SetAdministratorAsync(_db.Alice, _group, _db.Alice, true)).IsFailure, Is.True);
Assert.That((await _service.SetAdministratorAsync(_db.Alice, _group, _db.Outsider, true)).IsFailure, Is.True);
Assert.That((await _service.TransferOwnershipAsync(_db.Alice, _group, _db.Outsider)).IsFailure, Is.True);
Assert.That((await _service.TransferOwnershipAsync(_db.Alice, _group, _db.Alice)).IsFailure, Is.True);
Assert.That((await _service.SetBanAsync(_db.Alice, _group, _db.Outsider, true)).Error.Type, Is.EqualTo(ErrorType.NotFound));
}
[TestCase(0, 1, "")]
[TestCase(366, 1, "")]
[TestCase(1, -1, "")]
[TestCase(1, 1000001, "")]
[TestCase(1, 1, null)]
public async Task InvalidInvitationLimitsAreRejected(int days, int limit, string? description) =>
Assert.That((await _service.CreateInvitationAsync(_db.Alice, _group, days, limit, description!)).Error.Type, Is.EqualTo(ErrorType.Validation));
[Test]
public async Task MissingAndUnauthorizedInvitationsCannotBeViewedOrRevoked()
{
Assert.That((await _service.PreviewInvitationAsync(_db.Bob, "unknown")).IsFailure, Is.True);
Assert.That((await _service.JoinByInvitationAsync(_db.Bob, "unknown")).IsFailure, Is.True);
Assert.That((await _service.InvitationsAsync(_db.Bob, _group)).IsFailure, Is.True);
Assert.That((await _service.RevokeInvitationAsync(_db.Bob, _group, Guid.NewGuid())).IsFailure, Is.True);
Assert.That((await _service.RevokeInvitationAsync(_db.Alice, _group, Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.SetRequiredChannelAsync(_db.Alice, Guid.Empty, true)).IsFailure, Is.True);
}
}
@@ -0,0 +1,70 @@
using Govor.Application.Medias;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Microsoft.EntityFrameworkCore;
namespace Govor.Application.Tests.Medias;
[TestFixture]
public class MediaAccessTests
{
private TestDatabase _db = null!;
private AccesserToDownloadMediaService _service = null!;
[SetUp] public void SetUp() { _db = new TestDatabase(); _service = new(_db.Context); }
[TearDown] public void TearDown() => _db.Dispose();
private async Task<MediaFile> AddMedia(MediaOwnerType type, Guid? owner = null)
{
var media = new MediaFile { Id = Guid.NewGuid(), UploaderId = _db.Alice, Url = "test.bin",
MineType = "application/octet-stream", OwnerType = type, OwnerId = owner, DateCreated = DateTime.UtcNow };
_db.Context.MediaFiles.Add(media);
await _db.Context.SaveChangesAsync();
return media;
}
[Test]
public async Task MessageAttachmentIsAvailableOnlyToChatParticipants()
{
var message = _db.AddMessage();
var media = await AddMedia(MediaOwnerType.Message, message.Id);
_db.Context.MediaAttachments.Add(new MediaAttachments { Id = Guid.NewGuid(), MessageId = message.Id, MediaFileId = media.Id });
await _db.Context.SaveChangesAsync();
Assert.That(await _service.HasAccessAsync(media.Id, _db.Alice), Is.True);
Assert.That(await _service.HasAccessAsync(media.Id, _db.Bob), Is.True);
Assert.That(await _service.HasAccessAsync(media.Id, _db.Outsider), Is.False);
}
[TestCase(MediaOwnerType.Avatar)]
[TestCase(MediaOwnerType.System)]
public async Task PublicMediaCanBeDownloaded(MediaOwnerType type) =>
Assert.That(await _service.HasAccessAsync((await AddMedia(type)).Id, _db.Outsider), Is.True);
[TestCase(MediaOwnerType.Message)]
[TestCase(MediaOwnerType.Reaction)]
[TestCase((MediaOwnerType)99)]
public async Task UnattachedMediaCannotBeDownloaded(MediaOwnerType type) =>
Assert.That(await _service.HasAccessAsync((await AddMedia(type)).Id, _db.Alice), Is.False);
[Test]
public async Task UnknownMediaCannotBeDownloaded() =>
Assert.That(await _service.HasAccessAsync(Guid.NewGuid(), _db.Alice), Is.False);
[TestCase(false)]
[TestCase(true)]
public async Task GroupAvatarRequiresMembershipForPrivateGroupAndRejectsBannedMembers(bool isPrivate)
{
var group = new ChatGroup { Id = Guid.NewGuid(), Name = "group", Description = "", IsPrivate = isPrivate };
_db.Context.ChatGroups.Add(group);
var member = new GroupMembership { Id = Guid.NewGuid(), GroupId = group.Id, UserId = _db.Bob };
_db.Context.GroupMemberships.Add(member);
await _db.Context.SaveChangesAsync();
var media = await AddMedia(MediaOwnerType.GroupAvatar, group.Id);
group.ImageId = media.Id;
await _db.Context.SaveChangesAsync();
Assert.That(await _service.HasAccessAsync(media.Id, _db.Bob), Is.True);
Assert.That(await _service.HasAccessAsync(media.Id, _db.Outsider), Is.EqualTo(!isPrivate));
member.IsBanned = true;
await _db.Context.SaveChangesAsync();
Assert.That(await _service.HasAccessAsync(media.Id, _db.Bob), Is.False);
}
}
@@ -0,0 +1,110 @@
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Application.Tests.Integration.Medias;
[TestFixture]
public class MediaServiceTests
{
private TestDatabase _db = null!;
private Mock<IStorageService> _storage = null!;
private MediaService _service = null!;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
_storage = new Mock<IStorageService>();
_storage.Setup(s => s.SaveAsync(It.IsAny<byte[]>(), It.IsAny<string>())).ReturnsAsync("folder/test.bin");
_storage.Setup(s => s.LoadAsync("folder/test.bin")).ReturnsAsync(() => new MemoryStream(new byte[] { 1, 2, 3 }));
_service = new(_storage.Object, _db.Context, NullLogger<MediaService>.Instance);
}
[TearDown] public void TearDown() => _db.Dispose();
private Task<SmartRes.Result<MediaUploadResult, Error>> Upload(MediaOwnerType type = MediaOwnerType.Message) =>
_service.UploadMediaAsync(new Media(_db.Alice, DateTime.UtcNow, "test.bin", new byte[] { 1, 2, 3 },
MediaType.File, "application/octet-stream", "", type, null));
[Test]
public async Task UploadReadByIdAndUrlAndDeleteRoundTrip()
{
var uploaded = (await Upload()).Value;
_db.Context.ChangeTracker.Clear();
Assert.That(await _service.HasMediaAsync(uploaded.MediaId), Is.True);
Assert.That(await _service.HasMediaByUrlAsync(uploaded.Url), Is.True);
foreach (var media in new[] { (await _service.GetMediaByIdAsync(uploaded.MediaId)).Value,
(await _service.GetMediaByUrlAsync(uploaded.Url)).Value })
{
Assert.That(media.Data, Is.EqualTo(new byte[] { 1, 2, 3 }));
Assert.That(media.UploaderId, Is.EqualTo(_db.Alice));
Assert.That(media.FileName, Is.EqualTo("test.bin"));
Assert.That(media.MimeType, Is.EqualTo("application/octet-stream"));
Assert.That(media.EncryptedKey, Is.Empty);
}
Assert.That((await _service.DeleteMediaAsync(uploaded.MediaId)).IsSuccess, Is.True);
Assert.That(await _service.HasMediaAsync(uploaded.MediaId), Is.False);
Assert.That(await _service.HasMediaByUrlAsync(uploaded.Url), Is.False);
_storage.Verify(s => s.RemoveAsync(uploaded.Url), Times.Once);
}
[Test]
public async Task UnknownMediaOperationsReturnNotFoundAndNeverReadStorage()
{
Assert.That((await _service.GetMediaByIdAsync(Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.GetMediaByUrlAsync("unknown")).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.DeleteMediaAsync(Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.AttachToMessageAsync(Guid.NewGuid(), Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.NotFound));
_storage.VerifyNoOtherCalls();
}
[TestCase("")]
[TestCase(" ")]
[TestCase(null)]
public async Task BlankUrlReturnsValidationError(string? url) =>
Assert.That((await _service.GetMediaByUrlAsync(url!)).Error.Type, Is.EqualTo(ErrorType.Validation));
[Test]
public async Task InvalidUploadReturnsFailureWithoutMetadata()
{
_storage.Setup(s => s.SaveAsync(It.IsAny<byte[]>(), It.IsAny<string>())).ThrowsAsync(new ArgumentException("bad data"));
Assert.That((await Upload()).IsFailure, Is.True);
Assert.That(await _db.Context.MediaFiles.CountAsync(), Is.Zero);
}
[TestCase(false)]
[TestCase(true)]
public async Task MissingStorageFileReturnsServerError(bool byUrl)
{
var uploaded = (await Upload()).Value;
_storage.Setup(s => s.LoadAsync(uploaded.Url)).ThrowsAsync(new FileNotFoundException());
var result = byUrl ? await _service.GetMediaByUrlAsync(uploaded.Url) : await _service.GetMediaByIdAsync(uploaded.MediaId);
Assert.That(result.Error.Type, Is.EqualTo(ErrorType.ServerError));
Assert.That(await _service.HasMediaAsync(uploaded.MediaId), Is.True);
}
[Test]
public async Task FailedStorageDeletePreservesMetadata()
{
var uploaded = (await Upload()).Value;
_storage.Setup(s => s.RemoveAsync(uploaded.Url)).ThrowsAsync(new IOException("disk failure"));
Assert.ThrowsAsync<IOException>(() => _service.DeleteMediaAsync(uploaded.MediaId));
Assert.That(await _service.HasMediaAsync(uploaded.MediaId), Is.True);
}
[Test]
public async Task MessageMediaCanBeAssignedButAvatarCannot()
{
var messageMedia = (await Upload()).Value;
var avatar = (await Upload(MediaOwnerType.Avatar)).Value;
var message = _db.AddMessage();
Assert.That((await _service.AttachToMessageAsync(messageMedia.MediaId, message.Id)).IsSuccess, Is.True);
Assert.That((await _service.AttachToMessageAsync(avatar.MediaId, message.Id)).IsFailure, Is.True);
_db.Context.ChangeTracker.Clear();
Assert.That((await _db.Context.MediaFiles.SingleAsync(m => m.Id == messageMedia.MediaId)).OwnerId, Is.EqualTo(message.Id));
Assert.That((await _db.Context.MediaFiles.SingleAsync(m => m.Id == avatar.MediaId)).OwnerType, Is.EqualTo(MediaOwnerType.Avatar));
}
}
@@ -0,0 +1,154 @@
using Govor.Application.Messages;
using Govor.Application.Messages.Parameters;
using Govor.Application.Tests.Support;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;
namespace Govor.Application.Tests.Integration.Messages;
[TestFixture]
public class MessageCommandBoundaryTests
{
private TestDatabase _db = null!;
private Guid _group;
private readonly DateTime _now = new(2026, 10, 24, 0, 0, 0, DateTimeKind.Utc);
[SetUp]
public async Task SetUp()
{
_db = new TestDatabase();
_group = Guid.NewGuid();
_db.Context.ChatGroups.Add(new ChatGroup { Id = _group, Name = "public", Description = "", OwnerUserId = _db.Alice });
_db.Context.GroupMemberships.Add(new GroupMembership { Id = Guid.NewGuid(), GroupId = _group, UserId = _db.Alice });
await _db.Context.SaveChangesAsync();
}
[TearDown] public void TearDown() => _db.Dispose();
private MessageSendingService Sender(GovorDbContext? db = null) => new(db ?? _db.Context, NullLogger<MessageSendingService>.Instance);
private MessageEditingService Editor(GovorDbContext? db = null, bool enabled = true) => new(db ?? _db.Context,
NullLogger<MessageEditingService>.Instance, Options.Create(new MessageEditingOptions { Enabled = enabled, MaxEditTimeMinutes = 5 }));
private Message GroupMessage() => _db.AddMessage(chat: _group, type: RecipientType.Group, sentAt: _now);
[Test]
public async Task PublicGroupMessagePersistsAttachmentsAndPushAtomically()
{
var file = new MediaFile { Id = Guid.NewGuid(), UploaderId = _db.Alice, Url = "photo.png",
MineType = "image/png", OwnerType = MediaOwnerType.Message };
_db.Context.MediaFiles.Add(file);
await _db.Context.SaveChangesAsync();
var sent = await Sender().SendMessageAsync(new("public content", null, _group, RecipientType.Group,
_db.Alice, _now, new[] { new SendMedia(file.Id, "") }));
Assert.That(sent.IsSuccess, Is.True);
Assert.That(await _db.Context.MediaAttachments.CountAsync(a => a.MessageId == sent.Message.Id), Is.EqualTo(1));
Assert.That(await _db.Context.ChatPushNotifications.AnyAsync(p => p.MessageId == sent.Message.Id), Is.True);
}
[TestCase("empty")]
[TestCase("too-long")]
[TestCase("too-many-files")]
[TestCase("bad-envelope")]
[TestCase("bad-type")]
[TestCase("missing-group")]
[TestCase("missing-chat")]
[TestCase("missing-media")]
[TestCase("foreign-reply")]
public async Task InvalidSendDoesNotPersistMessageOrPush(string reason)
{
var content = reason == "empty" ? "" : reason == "too-long" ? new string('x', Govor.Application.E2ee.E2eeProtocol.MaxEnvelopeLength + 1) :
reason == "bad-envelope" ? Govor.Application.E2ee.E2eeProtocol.Prefix + "bad" : "content";
var files = reason == "too-many-files" ? Enumerable.Range(0, 101).Select(_ => new SendMedia(Guid.NewGuid(), "")).ToArray() :
reason == "missing-media" ? new[] { new SendMedia(Guid.NewGuid(), "") } : Array.Empty<SendMedia>();
var type = reason == "bad-type" ? (RecipientType)99 : reason == "missing-chat" ? RecipientType.User : RecipientType.Group;
var target = reason is "missing-group" or "missing-chat" ? Guid.NewGuid() : _group;
var request = new SendMessage(content, reason == "foreign-reply" ? Guid.NewGuid() : null, target, type, _db.Alice, _now, files);
Assert.That((await Sender().SendMessageAsync(request)).IsSuccess, Is.False);
Assert.That(await _db.Context.Messages.CountAsync(), Is.Zero);
Assert.That(await _db.Context.ChatPushNotifications.CountAsync(), Is.Zero);
}
[Test]
public async Task PublicGroupEditPersistsAndReturnsOriginalContext()
{
var message = GroupMessage();
var result = await Editor().EditMessageAsync(new(_db.Alice, message.Id, "edited", _now.AddMinutes(1)));
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.OriginalMessage!.Id, Is.EqualTo(message.Id));
var stored = await _db.Context.Messages.AsNoTracking().SingleAsync();
Assert.That(stored.EncryptedContent, Is.EqualTo("edited"));
Assert.That(stored.IsEdited, Is.True);
Assert.That(stored.EditedAt, Is.EqualTo(_now.AddMinutes(1)));
}
[TestCase("missing")]
[TestCase("not-author")]
[TestCase("expired")]
[TestCase("blank")]
[TestCase("null")]
[TestCase("too-long")]
public async Task InvalidEditLeavesOriginalMessage(string reason)
{
var message = GroupMessage();
var content = reason == "blank" ? " " : reason == "null" ? null : reason == "too-long" ?
new string('x', Govor.Application.E2ee.E2eeProtocol.MaxEnvelopeLength + 1) : "edited";
var result = await Editor().EditMessageAsync(new(reason == "not-author" ? _db.Bob : _db.Alice,
reason == "missing" ? Guid.NewGuid() : message.Id, content!, reason == "expired" ? _now.AddMinutes(6) : _now.AddMinutes(1)));
Assert.That(result.IsSuccess, Is.False);
Assert.That((await _db.Context.Messages.AsNoTracking().SingleAsync()).EncryptedContent, Is.EqualTo("hello"));
}
[Test]
public async Task DisablingEditDeadlinePermitsAnOldPublicGroupMessage()
{
var message = GroupMessage();
Assert.That((await Editor(enabled: false).EditMessageAsync(new(_db.Alice, message.Id, "edited", _now.AddDays(1)))).IsSuccess, Is.True);
}
[TestCase("send")]
[TestCase("edit")]
[TestCase("delete")]
public async Task PersistenceFailureRollsBackGroupOperation(string operation)
{
var message = operation == "send" ? null : GroupMessage();
var predicate = operation == "send" ? "INSERT INTO \"ChatPushNotifications\"" :
operation == "edit" ? "UPDATE \"Messages\"" : "DELETE FROM \"Messages\"";
using var failed = _db.CreateContext(new FailDatabaseCommand(sql => sql.Contains(predicate, StringComparison.Ordinal)));
if (operation == "send")
Assert.ThrowsAsync<DbUpdateException>(() => Sender(failed).SendMessageAsync(new("content", null, _group, RecipientType.Group, _db.Alice, _now, [])));
else if (operation == "edit")
Assert.ThrowsAsync<DbUpdateException>(() => Editor(failed).EditMessageAsync(new(_db.Alice, message!.Id, "edited", _now)));
else
Assert.ThrowsAsync<DbUpdateException>(() => new MessageRemovingService(failed, NullLogger<MessageRemovingService>.Instance)
.DeleteMessageAsync(new(_db.Alice, message!.Id, true)));
Assert.That(await _db.Context.Messages.CountAsync(), Is.EqualTo(operation == "send" ? 0 : 1));
Assert.That(await _db.Context.ChatPushNotifications.CountAsync(), Is.Zero);
if (operation == "edit") Assert.That((await _db.Context.Messages.AsNoTracking().SingleAsync()).EncryptedContent, Is.EqualTo("hello"));
Assert.That(failed.ChangeTracker.Entries(), Is.Empty);
}
[Test]
public async Task DeleteValidatesMissingMessageAndExplicitGlobalRemoval()
{
var service = new MessageRemovingService(_db.Context, NullLogger<MessageRemovingService>.Instance);
Assert.That((await service.DeleteMessageAsync(new(_db.Alice, Guid.NewGuid(), true))).Error.Code, Is.EqualTo("Message.NotFound"));
var message = GroupMessage();
Assert.That((await service.DeleteMessageAsync(new(_db.Alice, message.Id, false))).Error.Code, Is.EqualTo("Message.HideNotSupported"));
Assert.That((await service.DeleteMessageAsync(new(_db.Bob, message.Id, true))).Error.Code, Is.EqualTo("Chat.AccessDenied"));
Assert.That(await _db.Context.Messages.AnyAsync(m => m.Id == message.Id), Is.True);
}
[Test]
public async Task GroupHistoryUsesMembershipAndBoundaryPagination()
{
var messages = Enumerable.Range(0, 3).Select(i => _db.AddMessage(chat: _group, type: RecipientType.Group, sentAt: _now.AddMinutes(i))).ToArray();
var loader = new MessagesLoader(_db.Context);
Assert.That((await loader.LoadMessagesInChatGroup(_group, _db.Alice, messages[1].Id, 1, 1)).Value.Select(m => m.Id),
Is.EqualTo(messages.Select(m => m.Id)));
Assert.That((await loader.LoadMessagesInChatGroup(_group, _db.Bob, null)).IsFailure, Is.True);
Assert.That((await loader.LoadMessagesInChatGroup(Guid.Empty, _db.Alice, null)).IsFailure, Is.True);
Assert.That(await _db.Context.HasChatAccessAsync(Guid.Empty, _group, RecipientType.Group), Is.False);
Assert.That(await _db.Context.HasChatAccessAsync(_db.Alice, Guid.Empty, RecipientType.Group), Is.False);
Assert.That(await _db.Context.HasChatAccessAsync(_db.Alice, _group, (RecipientType)99), Is.False);
}
}
@@ -0,0 +1,60 @@
using Govor.Application.Messages;
using Govor.Domain.Models.Messages;
using Microsoft.EntityFrameworkCore;
namespace Govor.Application.Tests.Messages;
[TestFixture]
public class MessagesLoaderTests
{
private TestDatabase _db = null!;
private MessagesLoader _loader = null!;
[SetUp] public void SetUp() { _db = new TestDatabase(); _loader = new(_db.Context); }
[TearDown] public void TearDown() => _db.Dispose();
[Test]
public async Task LatestPageIsChronologicalAndLimited()
{
var start = DateTime.UtcNow.AddHours(-1);
var messages = Enumerable.Range(0, 5).Select(i => _db.AddMessage(sentAt: start.AddMinutes(i))).ToArray();
var result = await _loader.LoadMessagesInUserChat(_db.ChatId, _db.Bob, null, 3, 0);
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.Value.Select(m => m.Id), Is.EqualTo(messages.Skip(2).Select(m => m.Id)));
}
[Test]
public async Task AnchorIncludesRequestedMessagesOnBothSides()
{
var start = DateTime.UtcNow.AddHours(-1);
var messages = Enumerable.Range(0, 5).Select(i => _db.AddMessage(sentAt: start.AddMinutes(i))).ToArray();
var result = await _loader.LoadMessagesInUserChat(_db.ChatId, _db.Alice, messages[2].Id, 1, 1);
Assert.That(result.Value.Select(m => m.Id), Is.EqualTo(messages.Skip(1).Take(3).Select(m => m.Id)));
}
[Test]
public async Task EqualTimestampsUseIdAsStableTieBreaker()
{
var now = DateTime.UtcNow;
for (var i = 1; i <= 5; i++) _db.AddMessage(sentAt: now, id: Guid.Parse($"00000000-0000-0000-0000-{i:D12}"));
var expected = await _db.Context.Messages.OrderBy(m => m.Id).Select(m => m.Id).ToArrayAsync();
var result = await _loader.LoadMessagesInUserChat(_db.ChatId, _db.Bob, expected[2], 1, 1);
Assert.That(result.Value.Select(m => m.Id), Is.EqualTo(expected.Skip(1).Take(3)));
}
[Test]
public async Task MissingAnchorReturnsEmptyPage()
{
_db.AddMessage();
var result = await _loader.LoadMessagesInUserChat(_db.ChatId, _db.Alice, Guid.NewGuid());
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.Value, Is.Empty);
}
[Test]
public async Task OutsiderCannotLoadPrivateChat() =>
Assert.That((await _loader.LoadMessagesInUserChat(_db.ChatId, _db.Outsider, null)).IsFailure, Is.True);
[Test]
public async Task EmptyConversationIsRejected() =>
Assert.That((await _loader.LoadMessagesInUserChat(Guid.Empty, _db.Alice, null)).IsFailure, Is.True);
}
@@ -0,0 +1,43 @@
using Govor.Application.Messages;
using Govor.Application.Infrastructure.Common;
using Govor.Domain.Models.Messages;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Application.Tests.Integration.Messages;
[TestFixture]
public class ReadBoundaryTests
{
[Test]
public async Task EmptyChatReturnsZeroAndMissingBoundaryDoesNotCreateReceipts()
{
using var db = new TestDatabase();
var reader = new MessageReadingService(db.Context, NullLogger<MessageReadingService>.Instance,
Mock.Of<INowDateTimeProvider>(c => c.Now == DateTime.UtcNow.Date));
var empty = await reader.ReadChatAsync(db.Bob, db.ChatId, RecipientType.User);
Assert.That(empty.IsSuccess, Is.True);
Assert.That(empty.Value.ReadCount, Is.Zero);
Assert.That(empty.Value.UnreadCount, Is.Zero);
Assert.That((await reader.ReadChatAsync(db.Bob, db.ChatId, RecipientType.User, upToMessageId: Guid.NewGuid())).Error.Code,
Is.EqualTo("Message.Read.BoundaryNotFound"));
Assert.That((await reader.ReadMessageAsync(db.Bob, Guid.NewGuid())).Error.Code, Is.EqualTo("Message.NotFound"));
Assert.That((await reader.GetUnreadCountAsync(db.Outsider, db.ChatId, RecipientType.User)).IsFailure, Is.True);
Assert.That(await db.Context.MessageViews.CountAsync(), Is.Zero);
}
[Test]
public async Task InvalidSelectionsAndOwnMessagesCannotBeMarkedRead()
{
using var db = new TestDatabase();
var reader = new MessageReadingService(db.Context, NullLogger<MessageReadingService>.Instance, Mock.Of<INowDateTimeProvider>());
var own = db.AddMessage(sender: db.Bob);
Assert.That((await reader.ReadChatAsync(db.Bob, db.ChatId, RecipientType.User, new[] { own.Id })).Error.Code, Is.EqualTo("Message.Read.OwnMessage"));
foreach (var selection in new[] { Array.Empty<Guid>(), new[] { Guid.Empty }, Enumerable.Repeat(own.Id, 101).ToArray() })
Assert.That((await reader.ReadChatAsync(db.Bob, db.ChatId, RecipientType.User, selection)).IsFailure, Is.True);
Assert.That((await reader.ReadChatAsync(db.Bob, db.ChatId, RecipientType.User, new[] { own.Id }, own.Id)).IsFailure, Is.True);
Assert.That(await db.Context.MessageViews.CountAsync(), Is.Zero);
}
}
@@ -0,0 +1,73 @@
using Govor.Application.PrivateUserChats;
using Govor.Application.Groups;
using Govor.Application.Infrastructure.AdminsStuff;
using Govor.Domain.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Application.Tests.PrivateUserChats;
[TestFixture]
public class UserPrivateChatsCreatorTests
{
private TestDatabase _db = null!;
private Mock<IPrivateChatGroupManager> _manager = null!;
private UserPrivateChatsCreator _service = null!;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
_manager = new Mock<IPrivateChatGroupManager>();
_service = new(_db.Context, _manager.Object, NullLogger<UserPrivateChatsCreator>.Instance);
}
[TearDown] public void TearDown() => _db.Dispose();
[Test]
public async Task ExistingChatIsFoundInEitherUserOrder()
{
Assert.That((await _service.CreateAsync(_db.Alice, _db.Bob)).Id, Is.EqualTo(_db.ChatId));
Assert.That((await _service.CreateAsync(_db.Bob, _db.Alice)).Id, Is.EqualTo(_db.ChatId));
Assert.That(await _db.Context.PrivateChats.CountAsync(), Is.EqualTo(1));
_manager.VerifyNoOtherCalls();
}
[Test]
public async Task NewChatIsSavedAndUsersJoinSignalRGroupOnce()
{
var chat = await _service.CreateAsync(_db.Alice, _db.Outsider);
Assert.That(await _db.Context.PrivateChats.AnyAsync(c => c.Id == chat.Id), Is.True);
await _service.CreateAsync(_db.Outsider, _db.Alice);
_manager.Verify(m => m.AddUsersToPrivateChatGroupAsync(It.Is<PrivateChat>(c => c.Id == chat.Id)), Times.Once);
}
[Test]
public async Task GroupListExcludesBannedAndUnrelatedMemberships()
{
var group = new ChatGroup { Id = Guid.NewGuid(), Name = "group", Description = "" };
_db.Context.ChatGroups.Add(group);
_db.Context.GroupMemberships.AddRange(
new GroupMembership { Id = Guid.NewGuid(), GroupId = group.Id, UserId = _db.Alice },
new GroupMembership { Id = Guid.NewGuid(), GroupId = group.Id, UserId = _db.Bob, IsBanned = true });
await _db.Context.SaveChangesAsync();
var getter = new UserGroupsGetterService(_db.Context);
Assert.That((await getter.GetUserGroupsAsync(_db.Alice)).Select(g => g.Id), Is.EqualTo(new[] { group.Id }));
Assert.That(await getter.GetUserGroupsAsync(_db.Bob), Is.Empty);
Assert.That(await getter.GetUserGroupsAsync(_db.Outsider), Is.Empty);
}
[Test]
public async Task InvitationGeneratorPersistsUniqueCodesAndMetadata()
{
var generator = new InvitationGenerator(_db.Context);
var end = DateTime.UtcNow.Date.AddDays(2);
var first = await generator.GenerateInvitationCode(end, 5, true, "admin");
var second = await generator.GenerateInvitationCode(end, 10, false);
Assert.That(first, Is.Not.EqualTo(second));
var invite = await _db.Context.Invitations.AsNoTracking().SingleAsync(i => i.Code == first);
Assert.That(invite.EndDate, Is.EqualTo(end));
Assert.That(invite.MaxParticipants, Is.EqualTo(5));
Assert.That(invite.IsAdmin, Is.True);
Assert.That(invite.Description, Is.EqualTo("admin"));
}
}
@@ -0,0 +1,62 @@
using Govor.Application.Profiles;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
namespace Govor.Application.Tests.Profiles;
[TestFixture]
public class ProfileServiceTests
{
private TestDatabase _db = null!;
private ProfileService _service = null!;
[SetUp] public void SetUp() { _db = new TestDatabase(); _service = new(_db.Context, NullLogger<ProfileService>.Instance); }
[TearDown] public void TearDown() => _db.Dispose();
[Test]
public async Task ReadAndUpdateDescriptionPersistWithoutChangingOtherUsers()
{
Assert.That((await _service.SetDescription("new description", _db.Alice)).IsSuccess, Is.True);
var profile = (await _service.GetUserProfileAsync(_db.Alice)).Value;
Assert.That(profile.Id, Is.EqualTo(_db.Alice));
Assert.That(profile.Description, Is.EqualTo("new description"));
Assert.That((await _service.GetUserProfileAsync(_db.Bob)).Value.Description, Is.Empty);
}
[Test]
public async Task MissingUserReturnsNotFound()
{
Assert.That((await _service.GetUserProfileAsync(Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.SetDescription("test", Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.NotFound));
}
[TestCase(true, MediaOwnerType.Avatar, true)]
[TestCase(false, MediaOwnerType.Avatar, false)]
[TestCase(true, MediaOwnerType.Message, false)]
public async Task IconMustBeOwnUploadedAvatar(bool owned, MediaOwnerType type, bool success)
{
var media = new MediaFile { Id = Guid.NewGuid(), UploaderId = owned ? _db.Alice : _db.Bob,
Url = "avatar.png", MineType = "image/png", OwnerType = type };
_db.Context.MediaFiles.Add(media);
await _db.Context.SaveChangesAsync();
Assert.That((await _service.SetNewIcon(_db.Alice, media.Id)).IsSuccess, Is.EqualTo(success));
Assert.That((await _service.GetUserProfileAsync(_db.Alice)).Value.IconId,
Is.EqualTo(success ? media.Id : Guid.Empty));
}
[Test]
public async Task AvatarOfDeletedAccountDoesNotPermitUpdatingMissingProfile()
{
var media = new MediaFile { Id = Guid.NewGuid(), UploaderId = _db.Outsider, Url = "avatar.png",
MineType = "image/png", OwnerType = MediaOwnerType.Avatar };
_db.Context.MediaFiles.Add(media);
await _db.Context.SaveChangesAsync();
await _db.Context.Users.Where(u => u.Id == _db.Outsider).ExecuteDeleteAsync();
Assert.That((await _service.SetNewIcon(_db.Outsider, media.Id)).Error.Type, Is.EqualTo(ErrorType.NotFound));
}
[Test]
public async Task UnknownMediaCannotBeUsedAsIcon() =>
Assert.That((await _service.SetNewIcon(_db.Alice, Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.Forbidden));
}
@@ -0,0 +1,103 @@
using Govor.Application.PushNotifications;
using Govor.Application.Infrastructure.Common;
using Govor.Application.Tests.Support;
using Govor.Domain.Common;
using Govor.Domain.Models.Users;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Application.Tests.Integration.PushNotifications;
[TestFixture]
public class PushTokenServiceTests
{
private TestDatabase _db = null!;
private PushTokenService _service = null!;
private readonly DateTime _now = new(2026, 10, 24, 0, 0, 0, DateTimeKind.Utc);
private INowDateTimeProvider Clock => Mock.Of<INowDateTimeProvider>(c => c.Now == _now);
[SetUp] public void SetUp() { _db = new TestDatabase(); _service = new(_db.Context, Clock, NullLogger<PushTokenService>.Instance); }
[TearDown] public void TearDown() => _db.Dispose();
private async Task<Guid> Add(Guid user, string token, bool revoked = false, bool expired = false, bool active = true)
{
var session = new UserSession { UserId = user, RefreshTokenHash = token, ExpiresAt = _now.AddDays(expired ? -1 : 1), IsRevoked = revoked };
_db.Context.UserSessions.Add(session);
_db.Context.UserPushTokens.Add(new UserPushToken { UserId = user, UserSessionId = session.Id,
Token = token, Platform = "android", IsActive = active });
await _db.Context.SaveChangesAsync();
return session.Id;
}
[Test]
public async Task TokenQueriesFilterOwnerExpiryRevocationAndActivity()
{
var alice = await Add(_db.Alice, "alice");
await Add(_db.Alice, "expired", expired: true);
await Add(_db.Alice, "revoked", revoked: true);
await Add(_db.Alice, "inactive", active: false);
await Add(_db.Bob, "bob");
Assert.That((await _service.GetStringsActiveTokensAsync(_db.Alice)).Value, Is.EqualTo(new[] { "alice" }));
Assert.That((await _service.GetActiveTokenBySessionAsync(alice)).Value, Is.EqualTo("alice"));
Assert.That((await _service.GetUsersStringsActiveTokensAsync(new[] { _db.Alice, _db.Bob, _db.Alice })).Value,
Is.EquivalentTo(new[] { "alice", "bob" }));
Assert.That((await _service.GetActiveTokenBySessionAsync(Guid.NewGuid())).Value, Is.Null);
}
[Test]
public async Task DeactivationScopesAndRemovalPreserveUnrelatedTokens()
{
var first = await Add(_db.Alice, "first");
await Add(_db.Alice, "second");
await Add(_db.Bob, "bob");
Assert.That((await _service.DeactivateTokenBySessionAsync(first)).IsSuccess, Is.True);
Assert.That((await _service.GetStringsActiveTokensAsync(_db.Alice)).Value, Is.EqualTo(new[] { "second" }));
Assert.That((await _service.DeactivateAllTokensByUserIdAsync(_db.Alice)).IsSuccess, Is.True);
Assert.That((await _service.GetStringsActiveTokensAsync(_db.Alice)).Value, Is.Empty);
Assert.That((await _service.GetStringsActiveTokensAsync(_db.Bob)).Value, Is.EqualTo(new[] { "bob" }));
Assert.That((await _service.RemoveTokensAsync(new[] { "first", "second", "unknown" })).IsSuccess, Is.True);
Assert.That(await _db.Context.UserPushTokens.AsNoTracking().Select(t => t.Token).ToListAsync(), Is.EqualTo(new[] { "bob" }));
Assert.That((await _service.RemoveTokensAsync(Array.Empty<string>())).IsSuccess, Is.True);
Assert.That((await _service.RemoveTokensAsync(null!)).IsSuccess, Is.True);
}
[Test]
public async Task EveryDatabaseOperationReturnsFailureWhenItsCommandFails()
{
using var failed = _db.CreateContext(new FailDatabaseCommand());
var service = new PushTokenService(failed, Clock, NullLogger<PushTokenService>.Instance);
Assert.That((await service.DeactivateTokenBySessionAsync(Guid.NewGuid())).IsFailure, Is.True);
Assert.That((await service.DeactivateAllTokensByUserIdAsync(_db.Alice)).IsFailure, Is.True);
Assert.That((await service.GetStringsActiveTokensAsync(_db.Alice)).IsFailure, Is.True);
Assert.That((await service.GetUsersStringsActiveTokensAsync(new[] { _db.Alice })).IsFailure, Is.True);
Assert.That((await service.GetActiveTokenBySessionAsync(Guid.NewGuid())).IsFailure, Is.True);
Assert.That((await service.RemoveTokensAsync(new[] { "token" })).IsFailure, Is.True);
}
[TestCase("empty")]
[TestCase("long-token")]
[TestCase("long-platform")]
public async Task InvalidTokenArgumentsDoNotCreateRows(string kind)
{
var token = kind == "empty" ? "" : kind == "long-token" ? new string('t', 513) : "token";
var platform = kind == "long-platform" ? new string('p', 51) : "android";
Assert.That((await _service.AddOrUpdateTokenAsync(_db.Alice, Guid.NewGuid(), token, platform)).Error.Type, Is.EqualTo(ErrorType.Validation));
Assert.That(await _db.Context.UserPushTokens.CountAsync(), Is.Zero);
}
[Test]
public async Task TwoExistingTokenRowsMergeWhenDeviceChangesAccount()
{
var alice = await Add(_db.Alice, "shared");
var bob = await Add(_db.Bob, "old-bob");
Assert.That((await _service.AddOrUpdateTokenAsync(_db.Bob, bob, "shared", "ios")).IsSuccess, Is.True);
_db.Context.ChangeTracker.Clear();
var token = await _db.Context.UserPushTokens.SingleAsync();
Assert.That(token.UserId, Is.EqualTo(_db.Bob));
Assert.That(token.UserSessionId, Is.EqualTo(bob));
Assert.That(token.Token, Is.EqualTo("shared"));
Assert.That(token.Platform, Is.EqualTo("ios"));
Assert.That((await _service.GetActiveTokenBySessionAsync(alice)).Value, Is.Null);
}
}
@@ -0,0 +1,158 @@
using Govor.Application.Infrastructure.Common;
using Govor.Application.Reactions;
using Govor.Application.Tests.Support;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Reactions;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Application.Tests.Integration.Reactions;
[TestFixture]
public class ReactionPackBoundaryTests
{
private TestDatabase _db = null!;
private ReactionPackService _service = null!;
private Mock<IReactionMediaProcessor> _processor = null!;
private Mock<IStorageService> _storage = null!;
private readonly DateTime _now = new(2026, 10, 24, 0, 0, 0, DateTimeKind.Utc);
private ReactionPackService Service(GovorDbContext db) => new(db, Mock.Of<INowDateTimeProvider>(c => c.Now == _now),
_processor.Object, _storage.Object, NullLogger<ReactionPackService>.Instance);
[SetUp]
public async Task SetUp()
{
_db = new TestDatabase();
var invite = new Invitation { Id = Guid.NewGuid(), Code = "admin", Description = "", IsAdmin = true };
_db.Context.Invitations.Add(invite);
(await _db.Context.Users.SingleAsync(u => u.Id == _db.Alice)).InviteId = invite.Id;
await _db.Context.SaveChangesAsync();
_processor = new Mock<IReactionMediaProcessor>(MockBehavior.Strict);
_storage = new Mock<IStorageService>(MockBehavior.Strict);
_service = Service(_db.Context);
}
[TearDown] public void TearDown() => _db.Dispose();
private async Task<ReactionPack> Pack() => (await _service.CreateAsync(_db.Alice, "Custom", "")).Value;
[Test]
public async Task UpdateDisableAndHistoryPreserveDefinitions()
{
var pack = await Pack();
var item = (await _service.AddEmojiAsync(_db.Alice, pack.Id, "like", "👍")).Value;
var updated = await _service.UpdateAsync(_db.Alice, pack.Id, " Renamed ", " details ", true);
Assert.That(updated.Value.Name, Is.EqualTo("Renamed"));
Assert.That(updated.Value.Description, Is.EqualTo("details"));
Assert.That((await _service.DisableReactionAsync(_db.Alice, pack.Id, item.Id)).IsSuccess, Is.True);
Assert.That((await _service.GetAsync(pack.Id)).Value.Reactions, Is.Empty);
Assert.That((await _service.GetAsync(pack.Id, includeDisabled: true)).Value.Reactions.Single().Id, Is.EqualTo(item.Id));
Assert.That((await _service.GetReactionAsync(item.Id)).Value.IsEnabled, Is.False);
Assert.That((await _service.UpdateAsync(_db.Alice, pack.Id, "Renamed", "", false)).IsSuccess, Is.True);
Assert.That((await _service.GetAsync(pack.Id)).IsFailure, Is.True);
Assert.That((await _service.GetAsync(pack.Id, true)).IsSuccess, Is.True);
Assert.That((await _service.GetSharedAsync(pack.ShareCode)).IsFailure, Is.True);
Assert.That((await _service.SubscribeAsync(_db.Bob, pack.Id, true)).IsFailure, Is.True);
Assert.That((await _service.ListAsync(_db.Bob, includeDisabled: true)).Any(p => p.Id == pack.Id), Is.True);
}
[Test]
public async Task DefaultPackCannotBeChangedDisabledOrUninstalled()
{
var pack = await _db.Context.ReactionPacks.SingleAsync(p => p.IsDefault);
var item = await _db.Context.ReactionItems.FirstAsync(r => r.PackId == pack.Id);
Assert.That((await _service.UpdateAsync(_db.Alice, pack.Id, "default", "", true)).IsFailure, Is.True);
Assert.That((await _service.DisableAsync(_db.Alice, pack.Id)).IsFailure, Is.True);
Assert.That((await _service.DisableReactionAsync(_db.Alice, pack.Id, item.Id)).IsFailure, Is.True);
Assert.That((await _service.SubscribeAsync(_db.Bob, pack.Id, false)).IsFailure, Is.True);
Assert.That((await _service.SubscribeAsync(_db.Bob, pack.Id, true)).IsSuccess, Is.True);
}
[Test]
public async Task MissingPackOrItemReturnsFailureForEveryMutation()
{
var id = Guid.NewGuid();
Assert.That((await _service.GetAsync(id)).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.GetReactionAsync(id)).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.GetSharedAsync("missing")).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.UpdateAsync(_db.Alice, id, "name", "", true)).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.DisableAsync(_db.Alice, id)).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.DisableReactionAsync(_db.Alice, id, id)).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.AddEmojiAsync(_db.Alice, id, "name", "👍")).IsFailure, Is.True);
}
[Test]
public async Task NonAdminCannotMutatePacksOrUploadFiles()
{
var pack = await Pack();
Assert.That((await _service.CreateAsync(_db.Bob, "name", "")).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _service.UpdateAsync(_db.Bob, pack.Id, "name", "", true)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _service.DisableAsync(_db.Bob, pack.Id)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _service.DisableReactionAsync(_db.Bob, pack.Id, Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _service.AddEmojiAsync(_db.Bob, pack.Id, "name", "👍")).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _service.AddMediaAsync(_db.Bob, pack.Id, "name", new byte[] { 1 })).Error.Type, Is.EqualTo(ErrorType.Forbidden));
_processor.VerifyNoOtherCalls();
_storage.VerifyNoOtherCalls();
}
[TestCase("")]
[TestCase(" ")]
[TestCase("letters")]
[TestCase("👍👍")]
public async Task InvalidEmojiDoesNotCreateReaction(string emoji)
{
var pack = await Pack();
Assert.That((await _service.AddEmojiAsync(_db.Alice, pack.Id, "name", emoji)).IsFailure, Is.True);
Assert.That(await _db.Context.ReactionItems.CountAsync(r => r.PackId == pack.Id), Is.Zero);
}
[TestCase("name")]
[TestCase("description")]
[TestCase("reaction")]
public async Task OversizedTextIsRejected(string field)
{
var pack = await Pack();
if (field == "name") Assert.That((await _service.CreateAsync(_db.Alice, new string('x', 101), "")).IsFailure, Is.True);
if (field == "description") Assert.That((await _service.UpdateAsync(_db.Alice, pack.Id, "name", new string('x', 501), true)).IsFailure, Is.True);
if (field == "reaction") Assert.That((await _service.AddEmojiAsync(_db.Alice, pack.Id, "", "👍")).IsFailure, Is.True);
}
[Test]
public async Task DisabledEntriesStillCountTowardPackLimit()
{
var pack = await Pack();
_db.Context.ReactionItems.AddRange(Enumerable.Range(0, 100).Select(i => new ReactionItem {
Id = Guid.NewGuid(), PackId = pack.Id, Name = "item-" + i, Code = ":test_" + i + ":", Emoji = "👍", IsEnabled = false }));
await _db.Context.SaveChangesAsync();
Assert.That((await _service.AddEmojiAsync(_db.Alice, pack.Id, "overflow", "👍")).IsFailure, Is.True);
}
[Test]
public async Task ProcessorFailureIsReturnedBeforeStorageWrite()
{
var pack = await Pack();
var error = Error.Validation("Media.Invalid", "bad image");
_processor.Setup(p => p.ProcessAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(Result.Failure<ProcessedReactionMedia>(error));
Assert.That((await _service.AddMediaAsync(_db.Alice, pack.Id, "name", new byte[] { 1 })).Error, Is.SameAs(error));
_storage.VerifyNoOtherCalls();
}
[TestCase(false)]
[TestCase(true)]
public async Task FailedDatabaseWriteRollsBackMediaAndAttemptsStorageCleanup(bool cleanupFails)
{
var pack = await Pack();
_processor.Setup(p => p.ProcessAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>())).ReturnsAsync(
new ProcessedReactionMedia(new byte[] { 1 }, ReactionKind.Image, "image/png", ".png", 10, 10, 0));
_storage.Setup(s => s.SaveAsync(It.IsAny<byte[]>(), It.IsAny<string>())).ReturnsAsync("failed.png");
if (cleanupFails) _storage.Setup(s => s.RemoveAsync("failed.png")).ThrowsAsync(new IOException("cleanup failure"));
else _storage.Setup(s => s.RemoveAsync("failed.png")).Returns(Task.CompletedTask);
using var failed = _db.CreateContext(new FailDatabaseCommand(sql => sql.Contains("INSERT INTO \"MediaFiles\"", StringComparison.Ordinal)));
Assert.ThrowsAsync<DbUpdateException>(() => Service(failed).AddMediaAsync(_db.Alice, pack.Id, "name", new byte[] { 1 }));
_storage.Verify(s => s.RemoveAsync("failed.png"), Times.Once);
Assert.That(await _db.Context.ReactionItems.CountAsync(r => r.PackId == pack.Id), Is.Zero);
Assert.That(await _db.Context.MediaFiles.CountAsync(), Is.Zero);
Assert.That(failed.ChangeTracker.Entries(), Is.Empty);
}
}
@@ -0,0 +1,66 @@
using Govor.Application.Infrastructure.Common;
using Govor.Application.Reactions;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Reactions;
using Microsoft.EntityFrameworkCore;
using Moq;
namespace Govor.Application.Tests.Integration.Reactions;
[TestFixture]
public class ReactionPolicyBoundaryTests
{
private TestDatabase _db = null!;
private MessageReactionService _service = null!;
private Guid _group;
[SetUp]
public async Task SetUp()
{
_db = new TestDatabase();
_group = Guid.NewGuid();
_db.Context.ChatGroups.Add(new ChatGroup { Id = _group, Name = "channel", Description = "", IsChannel = true, OwnerUserId = _db.Alice });
_db.Context.GroupMemberships.Add(new GroupMembership { Id = Guid.NewGuid(), GroupId = _group, UserId = _db.Alice });
await _db.Context.SaveChangesAsync();
_service = new(_db.Context, Mock.Of<INowDateTimeProvider>(c => c.Now == DateTime.UtcNow.Date));
}
[TearDown] public void TearDown() => _db.Dispose();
[TestCase("mode")]
[TestCase("null")]
[TestCase("too-many")]
[TestCase("empty-id")]
[TestCase("wrong-mode")]
[TestCase("unavailable")]
public async Task InvalidPolicyDoesNotChangeModeVersionOrAllowedReactions(string reason)
{
var ids = reason == "null" ? null : reason == "too-many" ? Enumerable.Repeat(Guid.NewGuid(), 101).ToArray() :
reason == "empty-id" ? new[] { Guid.Empty } : new[] { Guid.NewGuid() };
var mode = reason == "mode" ? (ChannelReactionMode)99 : reason == "wrong-mode" ? ChannelReactionMode.All : ChannelReactionMode.Selected;
var result = await _service.SetPolicyAsync(_db.Alice, _group, mode, ids!);
Assert.That(result.Error.Type, Is.EqualTo(ErrorType.Validation));
var stored = await _db.Context.ChatGroups.AsNoTracking().SingleAsync();
Assert.That(stored.ReactionPolicyVersion, Is.Zero);
Assert.That(stored.ReactionMode, Is.EqualTo(ChannelReactionMode.All));
Assert.That(await _db.Context.ChannelAllowedReactions.CountAsync(), Is.Zero);
}
[Test]
public async Task MissingOrInaccessibleMessageAndGroupCannotBeRead()
{
var message = _db.AddMessage();
Assert.That((await _service.GetAsync(_db.Alice, Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _service.GetAsync(_db.Outsider, message.Id)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _service.GetPolicyAsync(_db.Outsider, _group)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _service.SetPolicyAsync(_db.Outsider, _group, ChannelReactionMode.None, [])).IsFailure, Is.True);
}
[Test]
public async Task OrdinaryGroupCannotReceiveChannelPolicy()
{
await _db.Context.ChatGroups.Where(g => g.Id == _group).ExecuteUpdateAsync(s => s.SetProperty(g => g.IsChannel, false));
Assert.That((await _service.SetPolicyAsync(_db.Alice, _group, ChannelReactionMode.None, [])).Error.Code,
Is.EqualTo("Reaction.Policy.NotChannel"));
}
}
@@ -0,0 +1,28 @@
using Govor.Application.PingHandler;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;
namespace Govor.Application.Tests.Users;
[TestFixture]
public class PingHandlerServiceTests
{
[Test]
public async Task PingUpdatesLastSeenAndThrottlesRepeatedRequests()
{
using var db = new TestDatabase();
using var cache = new MemoryCache(new MemoryCacheOptions());
var service = new PingHandlerService(db.Context, cache);
var old = DateTime.UtcNow.AddHours(-1);
await db.Context.Users.Where(u => u.Id == db.Alice).ExecuteUpdateAsync(s => s.SetProperty(u => u.WasOnline, old));
var before = DateTime.UtcNow;
await service.Ping(db.Alice);
var updated = await db.Context.Users.AsNoTracking().SingleAsync(u => u.Id == db.Alice);
Assert.That(updated.WasOnline, Is.GreaterThanOrEqualTo(before));
Assert.That(cache.TryGetValue($"LastPing_{db.Alice}", out DateTime _), Is.True);
await db.Context.Users.Where(u => u.Id == db.Alice).ExecuteUpdateAsync(s => s.SetProperty(u => u.WasOnline, old));
var storedBeforeThrottledPing = (await db.Context.Users.AsNoTracking().SingleAsync(u => u.Id == db.Alice)).WasOnline;
await service.Ping(db.Alice);
Assert.That((await db.Context.Users.AsNoTracking().SingleAsync(u => u.Id == db.Alice)).WasOnline, Is.EqualTo(storedBeforeThrottledPing));
}
}
@@ -0,0 +1,48 @@
using Govor.Application.PrivateUserChats;
using Govor.Domain.Common;
using Microsoft.EntityFrameworkCore;
namespace Govor.Application.Tests.Integration.Users;
[TestFixture]
public class ReaderTests
{
[Test]
public async Task PresenceReturnsPersistedLastSeenOrNullForMissingUser()
{
using var db = new TestDatabase();
var time = new DateTime(2026, 10, 24, 10, 0, 0, DateTimeKind.Utc);
await db.Context.Users.Where(u => u.Id == db.Alice).ExecuteUpdateAsync(s => s.SetProperty(u => u.WasOnline, time));
var reader = new UserPresenceReader(db.Context);
Assert.That(await reader.GetLastSeenAsync(db.Alice), Is.EqualTo(time));
Assert.That(await reader.GetLastSeenAsync(Guid.NewGuid()), Is.Null);
Assert.That(await reader.GetLastSeenAsync(Guid.Empty), Is.Null);
}
[Test]
public async Task PrivateChatReaderFiltersBothPositionsAndHandlesMissingChat()
{
using var db = new TestDatabase();
var reader = new UserPrivateChatsGetter(db.Context);
Assert.That((await reader.GetUserChatsAsync(db.Alice)).Select(c => c.Id), Is.EqualTo(new[] { db.ChatId }));
Assert.That((await reader.GetUserChatsAsync(db.Bob)).Select(c => c.Id), Is.EqualTo(new[] { db.ChatId }));
Assert.That(await reader.GetUserChatsAsync(db.Outsider), Is.Empty);
Assert.That((await reader.GetPrivateChatAsync(db.ChatId)).Value.Id, Is.EqualTo(db.ChatId));
Assert.That((await reader.GetPrivateChatAsync(Guid.NewGuid())).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That(await reader.ExistChatAsync(db.Alice, db.Bob), Is.True);
Assert.That(await reader.ExistChatAsync(db.Bob, db.Alice), Is.True);
Assert.That(await reader.ExistChatAsync(db.Alice, db.Outsider), Is.False);
}
[Test]
public async Task UsernameExistenceHandlesBlankUnknownAndExistingUsernames()
{
using var db = new TestDatabase();
var validator = new Govor.Application.Users.UserNameExistValidator(db.Context);
Assert.That(await validator.IsUsernameExistsAsync(" "), Is.False);
Assert.That(await validator.IsUsernameExistsAsync(null!), Is.False);
Assert.That(await validator.IsUsernameExistsAsync("missing"), Is.False);
Assert.That(await validator.IsUsernameExistsAsync(db.Alice.ToString()), Is.True);
}
}
@@ -0,0 +1,135 @@
using Govor.Application.Users.UserSessions.Crypto;
using Govor.Domain.Models.Users;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Application.Tests.Integration.Users;
[TestFixture]
public class SessionCryptoTests
{
private TestDatabase _db = null!;
private SessionKeyAttacher _attacher = null!;
private SessionKeysReader _reader = null!;
private OneTimePreKeysRotator _rotator = null!;
private Mock<ICurrentUserService> _current = null!;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
_current = new Mock<ICurrentUserService>();
_current.Setup(c => c.GetCurrentUserId()).Returns(_db.Alice);
_attacher = new(NullLogger<SessionKeyAttacher>.Instance, _current.Object, _db.Context);
_reader = new(NullLogger<SessionKeyAttacher>.Instance, _db.Context);
_rotator = new(NullLogger<SessionKeyAttacher>.Instance, _current.Object, _db.Context);
}
[TearDown] public void TearDown() => _db.Dispose();
private async Task<UserSession> Session(Guid? user = null, bool revoked = false, bool expired = false)
{
var session = new UserSession { UserId = user ?? _db.Alice, RefreshTokenHash = Guid.NewGuid().ToString(),
ExpiresAt = DateTime.UtcNow.AddDays(expired ? -1 : 1), IsRevoked = revoked };
_db.Context.UserSessions.Add(session);
await _db.Context.SaveChangesAsync();
return session;
}
private Task Attach(Guid id) => _attacher.AttachKeysAsync(id, new byte[] { 1 }, new byte[] { 2 },
new byte[] { 3 }, new[] { new byte[] { 4 }, new byte[] { 5 } });
[Test]
public async Task AttachesIdentitySignedAndOneTimeKeysAndReadsThemFromDatabase()
{
var session = await Session();
Assert.That(await _reader.HasKeysAttachedAsync(session.Id), Is.False);
await Attach(session.Id);
_db.Context.ChangeTracker.Clear();
Assert.That(await _reader.HasKeysAttachedAsync(session.Id), Is.True);
var keys = (await _reader.GetAllActiveKeysAsync(_db.Alice)).Single();
Assert.Multiple(() =>
{
Assert.That(keys.UserSessionId, Is.EqualTo(session.Id));
Assert.That(keys.PublicIdentityKey, Is.EqualTo(new byte[] { 1 }));
Assert.That(keys.SignedPreKey.PublicSignedPreKey, Is.EqualTo(new byte[] { 2 }));
Assert.That(keys.SignedPreKey.SignedPreKeySignature, Is.EqualTo(new byte[] { 3 }));
Assert.That(keys.OneTimePreKeys.Select(k => k.PublicKey[0]), Is.EquivalentTo(new byte[] { 4, 5 }));
});
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(session.Id), Is.EqualTo(2));
var bySession = await _reader.GetKeysBySessionIdAsync(session.Id);
Assert.That(bySession!.UserSession.Id, Is.EqualTo(session.Id));
Assert.That(bySession.OneTimePreKeys.Count, Is.EqualTo(2));
Assert.That(bySession.SignedPreKey, Is.Not.Null);
}
[Test]
public async Task CannotReplaceAttachedKeysOrAttachToAnotherUsersSession()
{
var own = await Session();
var other = await Session(_db.Bob);
await Attach(own.Id);
Assert.ThrowsAsync<InvalidOperationException>(() => Attach(own.Id));
Assert.ThrowsAsync<InvalidOperationException>(() => Attach(other.Id));
Assert.ThrowsAsync<ArgumentException>(() => Attach(Guid.NewGuid()));
Assert.That(await _reader.HasKeysAttachedAsync(other.Id), Is.False);
}
[Test]
public async Task ActiveKeysExcludeExpiredRevokedAndOtherUsersSessions()
{
var active = await Session();
var expired = await Session(expired: true);
var revoked = await Session(revoked: true);
var bob = await Session(_db.Bob);
foreach (var session in new[] { active, expired, revoked }) await Attach(session.Id);
_current.Setup(c => c.GetCurrentUserId()).Returns(_db.Bob);
await Attach(bob.Id);
_db.Context.ChangeTracker.Clear();
Assert.That((await _reader.GetAllActiveKeysAsync(_db.Alice)).Select(k => k.UserSessionId), Is.EqualTo(new[] { active.Id }));
Assert.That((await _reader.GetAllActiveKeysAsync(_db.Bob)).Select(k => k.UserSessionId), Is.EqualTo(new[] { bob.Id }));
}
[Test]
public async Task UsedKeyIsIdempotentAndRotationDeletesOnlyUsedKeys()
{
var session = await Session();
await Attach(session.Id);
var keys = await _db.Context.OneTimePreKeys.OrderBy(k => k.Id).ToListAsync();
await _rotator.MarkOneTimePreKeyAsUsedAsync(session.Id, keys[0].Id);
await _rotator.MarkOneTimePreKeyAsUsedAsync(session.Id, keys[0].Id);
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(session.Id), Is.EqualTo(1));
await _rotator.RotateOneTimePreKeysAsync(session.Id, new[] { new byte[] { 6 } });
_db.Context.ChangeTracker.Clear();
Assert.That(await _db.Context.OneTimePreKeys.AnyAsync(k => k.Id == keys[0].Id), Is.False);
Assert.That(await _db.Context.OneTimePreKeys.AnyAsync(k => k.Id == keys[1].Id), Is.True);
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(session.Id), Is.EqualTo(2));
await _rotator.RotateOneTimePreKeysAsync(session.Id, Array.Empty<byte[]>());
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(session.Id), Is.EqualTo(2));
}
[Test]
public async Task AnotherUserCannotRotateOrConsumeKeysOfThisSession()
{
var session = await Session();
await Attach(session.Id);
var key = await _db.Context.OneTimePreKeys.FirstAsync();
_current.Setup(c => c.GetCurrentUserId()).Returns(_db.Bob);
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _rotator.RotateOneTimePreKeysAsync(session.Id, new[] { new byte[] { 9 } }));
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _rotator.MarkOneTimePreKeyAsUsedAsync(session.Id, key.Id));
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(session.Id), Is.EqualTo(2));
}
[Test]
public async Task MissingSessionAndMismatchedKeyAreRejected()
{
var session = await Session();
await Attach(session.Id);
var key = await _db.Context.OneTimePreKeys.FirstAsync();
Assert.ThrowsAsync<ArgumentException>(() => _rotator.MarkOneTimePreKeyAsUsedAsync(Guid.NewGuid(), key.Id));
Assert.ThrowsAsync<ArgumentException>(() => _rotator.MarkOneTimePreKeyAsUsedAsync(session.Id, Guid.NewGuid()));
Assert.ThrowsAsync<ArgumentException>(() => _rotator.RotateOneTimePreKeysAsync(Guid.NewGuid(), Array.Empty<byte[]>()));
Assert.That(await _reader.GetKeysBySessionIdAsync(Guid.NewGuid()), Is.Null);
Assert.That(await _reader.GetRemainingOneTimePreKeysCountAsync(Guid.NewGuid()), Is.Zero);
}
}
@@ -0,0 +1,105 @@
using Govor.Application.Authentication.JWT;
using Govor.Application.Tests.Support;
using Govor.Application.PushNotifications;
using Govor.Domain.Common;
using Govor.Domain.Models.Users;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;
using Moq;
namespace Govor.Application.Tests.Integration.Users;
[TestFixture]
public class UserSessionFailureTests
{
[Test]
public async Task ReaderAndRevokerReturnFailuresWithoutTouchingPushTokensOnDatabaseErrors()
{
using var db = new TestDatabase();
var session = new UserSession { UserId = db.Alice, RefreshTokenHash = "hash", ExpiresAt = DateTime.UtcNow.AddDays(1) };
db.Context.UserSessions.Add(session);
await db.Context.SaveChangesAsync();
using var failed = db.CreateContext(new FailDatabaseCommand());
var push = new Mock<IPushTokenService>(MockBehavior.Strict);
var reader = new UserSessionReader(failed, NullLogger<UserSessionReader>.Instance);
var revoker = new UserSessionRevoker(failed, push.Object, NullLogger<UserSessionRevoker>.Instance);
Assert.That((await reader.GetAllSessionsAsync(db.Alice)).IsFailure, Is.True);
Assert.That((await revoker.CloseSessionByIdAsync(session.Id, db.Alice)).IsFailure, Is.True);
Assert.That((await revoker.CloseAllSessionsAsync(db.Alice)).IsFailure, Is.True);
push.VerifyNoOtherCalls();
Assert.That((await db.Context.UserSessions.AsNoTracking().SingleAsync()).IsRevoked, Is.False);
}
[Test]
public async Task OpeningSessionStopsAfterReaderFailure()
{
using var db = new TestDatabase();
var reader = new Mock<IUserSessionReader>();
var error = Error.ServerError("Sessions.Unavailable", "unavailable");
reader.Setup(r => r.GetAllSessionsAsync(db.Alice)).ReturnsAsync(Result.Failure<List<UserSession>>(error));
var jwt = new Mock<IJwtService>(MockBehavior.Strict);
var opener = new UserSessionOpener(NullLogger<UserSessionOpener>.Instance, reader.Object, db.Context,
Mock.Of<IJwtTokenHasher>(), Options.Create(new JwtRefreshOption()), jwt.Object);
var result = await opener.OpenSessionAsync(await db.Context.Users.SingleAsync(u => u.Id == db.Alice), "phone");
Assert.That(result.Error, Is.SameAs(error));
jwt.VerifyNoOtherCalls();
Assert.That(await db.Context.UserSessions.CountAsync(), Is.Zero);
}
[Test]
public async Task FailedSessionInsertReturnsFailureAndLeavesNoSession()
{
using var db = new TestDatabase();
using var failed = db.CreateContext(new FailDatabaseCommand(sql => sql.Contains("INSERT INTO \"UserSessions\"", StringComparison.Ordinal)));
var reader = new UserSessionReader(failed, NullLogger<UserSessionReader>.Instance);
var jwt = new Mock<IJwtService>();
jwt.Setup(j => j.GenerateAccessTokenAsync(It.IsAny<User>(), It.IsAny<Guid>())).ReturnsAsync("access");
jwt.Setup(j => j.GenerateRefreshTokenAsync(It.IsAny<User>())).ReturnsAsync("refresh");
var hash = new Mock<IJwtTokenHasher>();
hash.Setup(h => h.HashToken("refresh")).Returns("hash");
var opener = new UserSessionOpener(NullLogger<UserSessionOpener>.Instance, reader, failed, hash.Object,
Options.Create(new JwtRefreshOption { RefreshTokenLifetimeDays = 30 }), jwt.Object);
Assert.That((await opener.OpenSessionAsync(await db.Context.Users.SingleAsync(u => u.Id == db.Alice), null!)).IsFailure, Is.True);
Assert.That(await db.Context.UserSessions.CountAsync(), Is.Zero);
}
[Test]
public async Task RefreshDatabaseFailureReturnsFailure()
{
using var db = new TestDatabase();
using var failed = db.CreateContext(new FailDatabaseCommand());
var hash = Mock.Of<IJwtTokenHasher>(h => h.HashToken("token") == "hash");
var service = new UserSessionRefresher(NullLogger<UserSessionRefresher>.Instance,
Options.Create(new JwtRefreshOption()), hash, Mock.Of<IJwtService>(), failed);
Assert.That((await service.RefreshTokenAsync("token")).IsFailure, Is.True);
}
[Test]
public async Task RevocationBetweenTokenLookupAndRotationRejectsRefresh()
{
using var db = new TestDatabase();
var session = new UserSession { UserId = db.Alice, RefreshTokenHash = "old-hash", ExpiresAt = DateTime.UtcNow.AddDays(1) };
db.Context.UserSessions.Add(session);
await db.Context.SaveChangesAsync();
var jwt = new Mock<IJwtService>();
jwt.Setup(j => j.GenerateAccessTokenAsync(It.IsAny<User>(), session.Id)).ReturnsAsync("access");
jwt.Setup(j => j.GenerateRefreshTokenAsync(It.IsAny<User>())).Returns(async () =>
{
await db.Context.UserSessions.Where(s => s.Id == session.Id).ExecuteUpdateAsync(s => s.SetProperty(s => s.IsRevoked, true));
return "new";
});
var hash = new Mock<IJwtTokenHasher>();
hash.Setup(h => h.HashToken("old")).Returns("old-hash");
hash.Setup(h => h.HashToken("new")).Returns("new-hash");
using var context = db.CreateContext();
var service = new UserSessionRefresher(NullLogger<UserSessionRefresher>.Instance,
Options.Create(new JwtRefreshOption { RefreshTokenLifetimeDays = 30 }), hash.Object, jwt.Object, context);
var result = await service.RefreshTokenAsync("old");
Assert.That(result.Error.Type, Is.EqualTo(ErrorType.Unauthorized));
var stored = await db.Context.UserSessions.AsNoTracking().SingleAsync();
Assert.That(stored.RefreshTokenHash, Is.EqualTo("old-hash"));
Assert.That(stored.IsRevoked, Is.True);
}
}
@@ -0,0 +1,132 @@
using Govor.Application.Authentication.JWT;
using Govor.Application.Users.UserSessions;
using Govor.Application.PushNotifications;
using Govor.Domain.Common;
using Govor.Domain.Models.Users;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;
using Moq;
namespace Govor.Application.Tests.Users;
[TestFixture]
public class UserSessionTests
{
private TestDatabase _db = null!;
private Mock<IJwtService> _jwt = null!;
private Mock<IJwtTokenHasher> _hasher = null!;
private UserSessionReader _reader = null!;
private UserSessionRefresher _refresher = null!;
private UserSessionOpener _opener = null!;
private Mock<IPushTokenService> _push = null!;
private UserSessionRevoker _revoker = null!;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
_jwt = new Mock<IJwtService>();
_jwt.Setup(j => j.GenerateAccessTokenAsync(It.IsAny<User>(), It.IsAny<Guid>()))
.ReturnsAsync((User _, Guid sid) => "access-" + sid);
_jwt.Setup(j => j.GenerateRefreshTokenAsync(It.IsAny<User>())).ReturnsAsync(() => Guid.NewGuid().ToString());
_hasher = new Mock<IJwtTokenHasher>();
_hasher.Setup(h => h.HashToken(It.IsAny<string>())).Returns((string token) => "hash-" + token);
_reader = new UserSessionReader(_db.Context, NullLogger<UserSessionReader>.Instance);
var options = Options.Create(new JwtRefreshOption { RefreshTokenLifetimeDays = 30 });
_opener = new UserSessionOpener(NullLogger<UserSessionOpener>.Instance, _reader, _db.Context,
_hasher.Object, options, _jwt.Object);
_refresher = new UserSessionRefresher(NullLogger<UserSessionRefresher>.Instance, options,
_hasher.Object, _jwt.Object, _db.Context);
_push = new Mock<IPushTokenService>();
_push.Setup(p => p.DeactivateTokenBySessionAsync(It.IsAny<Guid>())).ReturnsAsync(Result.Success());
_push.Setup(p => p.DeactivateAllTokensByUserIdAsync(It.IsAny<Guid>())).ReturnsAsync(Result.Success());
_revoker = new UserSessionRevoker(_db.Context, _push.Object, NullLogger<UserSessionRevoker>.Instance);
}
[TearDown] public void TearDown() => _db.Dispose();
private async Task<UserSession> AddSession(Guid user, bool revoked = false, bool expired = false)
{
var session = new UserSession { UserId = user, RefreshTokenHash = "hash-" + Guid.NewGuid(),
ExpiresAt = DateTime.UtcNow.AddDays(expired ? -1 : 1), IsRevoked = revoked, DeviceInfo = "phone" };
_db.Context.UserSessions.Add(session);
await _db.Context.SaveChangesAsync();
return session;
}
[Test]
public async Task SameDeviceLabelStillCreatesDistinctSessionsAndStoresOnlyTokenHashes()
{
var user = await _db.Context.Users.SingleAsync(u => u.Id == _db.Alice);
var first = await _opener.OpenSessionAsync(user, "phone");
var second = await _opener.OpenSessionAsync(user, "phone");
Assert.That(first.IsSuccess && second.IsSuccess, Is.True);
var sessions = await _db.Context.UserSessions.AsNoTracking().ToListAsync();
Assert.That(sessions, Has.Count.EqualTo(2));
Assert.That(sessions.Select(s => s.Id).Distinct().Count(), Is.EqualTo(2));
Assert.That(sessions.Select(s => s.RefreshTokenHash), Is.EquivalentTo(
new[] { "hash-" + first.Value.refreshToken, "hash-" + second.Value.refreshToken }));
Assert.That(sessions.All(s => s.ExpiresAt > DateTime.UtcNow.AddDays(29)), Is.True);
}
[Test]
public async Task ReaderFiltersOwnerAndRevocation()
{
var own = await AddSession(_db.Alice);
await AddSession(_db.Alice, revoked: true);
await AddSession(_db.Bob);
Assert.That((await _reader.GetAllSessionsAsync(_db.Alice)).Value.Select(s => s.Id), Is.EqualTo(new[] { own.Id }));
Assert.That((await _reader.GetAllSessionsAsync(Guid.Empty)).IsFailure, Is.True);
}
[Test]
public async Task RefreshRotatesHashAndRejectsReplay()
{
var session = await AddSession(_db.Alice);
var oldToken = session.RefreshTokenHash["hash-".Length..];
var result = await _refresher.RefreshTokenAsync(oldToken);
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.Value.accessToken, Is.EqualTo("access-" + session.Id));
_db.Context.ChangeTracker.Clear();
Assert.That((await _db.Context.UserSessions.SingleAsync()).RefreshTokenHash,
Is.EqualTo("hash-" + result.Value.refreshToken));
Assert.That((await _refresher.RefreshTokenAsync(oldToken)).IsFailure, Is.True);
}
[TestCase(true, false)]
[TestCase(false, true)]
public async Task RevokedOrExpiredSessionCannotRefresh(bool revoked, bool expired)
{
var session = await AddSession(_db.Alice, revoked, expired);
Assert.That((await _refresher.RefreshTokenAsync(session.RefreshTokenHash["hash-".Length..])).IsFailure, Is.True);
_jwt.Verify(j => j.GenerateRefreshTokenAsync(It.IsAny<User>()), Times.Never);
}
[TestCase("")]
[TestCase(" ")]
[TestCase("unknown")]
public async Task InvalidRefreshTokenReturnsFailure(string token) =>
Assert.That((await _refresher.RefreshTokenAsync(token)).IsFailure, Is.True);
[Test]
public async Task SessionCanBeRevokedOnlyByOwnerAndPushTokenIsDeactivated()
{
var session = await AddSession(_db.Alice);
Assert.That((await _revoker.CloseSessionByIdAsync(session.Id, _db.Bob)).Error.Type, Is.EqualTo(ErrorType.NotFound));
_push.VerifyNoOtherCalls();
Assert.That((await _revoker.CloseSessionByIdAsync(session.Id, _db.Alice)).IsSuccess, Is.True);
Assert.That((await _db.Context.UserSessions.AsNoTracking().SingleAsync()).IsRevoked, Is.True);
_push.Verify(p => p.DeactivateTokenBySessionAsync(session.Id), Times.Once);
}
[Test]
public async Task CloseAllIsIdempotentAndKeepsOtherUsersSessions()
{
await AddSession(_db.Alice);
var bob = await AddSession(_db.Bob);
Assert.That((await _revoker.CloseAllSessionsAsync(_db.Alice)).IsSuccess, Is.True);
Assert.That((await _revoker.CloseAllSessionsAsync(_db.Alice)).IsSuccess, Is.True);
Assert.That((await _db.Context.UserSessions.AsNoTracking().SingleAsync(s => s.Id == bob.Id)).IsRevoked, Is.False);
_push.Verify(p => p.DeactivateAllTokensByUserIdAsync(_db.Alice), Times.Once);
}
}
@@ -0,0 +1,32 @@
using System.Data.Common;
using Microsoft.EntityFrameworkCore.Diagnostics;
namespace Govor.Application.Tests.Support;
// Inject a provider-independent command failure after schema/seed initialization.
internal sealed class FailDatabaseCommand(Func<string, bool>? matches = null, Func<Task>? beforeFailure = null) : DbCommandInterceptor
{
private readonly Func<string, bool> _matches = matches ?? (_ => true);
public override async ValueTask<InterceptionResult<DbDataReader>> ReaderExecutingAsync(DbCommand command,
CommandEventData eventData, InterceptionResult<DbDataReader> result, CancellationToken cancellationToken = default)
{
if (_matches(command.CommandText))
{
if (beforeFailure is not null) await beforeFailure();
throw new InvalidOperationException("Simulated database failure.");
}
return result;
}
public override async ValueTask<InterceptionResult<int>> NonQueryExecutingAsync(DbCommand command,
CommandEventData eventData, InterceptionResult<int> result, CancellationToken cancellationToken = default)
{
if (_matches(command.CommandText))
{
if (beforeFailure is not null) await beforeFailure();
throw new InvalidOperationException("Simulated database failure.");
}
return result;
}
}
@@ -0,0 +1,153 @@
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using AutoFixture;
using Govor.Domain.Models.Users;
using Microsoft.Extensions.Options;
using Microsoft.IdentityModel.Tokens;
using Moq;
namespace Govor.Application.Tests.Services.Authentication;
[TestFixture]
public class JwtServiceTests
{
private Fixture _fixture = null!;
private Mock<IOptions<JwtAccessOption>> _jwtOptionsMock = null!;
private Mock<IOptions<JwtRefreshOption>> _jwtRefreshOptionsMock = null!;
private Mock<IInvitesService> _invitesServiceMock = null!;
private IJwtService _jwtService = null!;
private JwtAccessOption _testJwtAccessOptions = null!;
private JwtRefreshOption _testJwtRefreshOptions = null!;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_fixture.Behaviors.OfType<ThrowingRecursionBehavior>().ToList().ForEach(b => _fixture.Behaviors.Remove(b));
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_testJwtAccessOptions = new JwtAccessOption
{
SecretKey = "THIS_IS_A_TEST_SECRET_KEY_THAT_IS_LONG_ENOUGH_1234", // Ensure key size is sufficient for HMACSHA256
Minutes = 5
};
_testJwtRefreshOptions = new JwtRefreshOption()
{
RefreshTokenLifetimeDays = 30
};
_jwtOptionsMock = new Mock<IOptions<JwtAccessOption>>();
_jwtOptionsMock.Setup(o => o.Value).Returns(_testJwtAccessOptions);
_jwtRefreshOptionsMock = new Mock<IOptions<JwtRefreshOption>>();
_jwtRefreshOptionsMock.Setup(o => o.Value).Returns(_testJwtRefreshOptions);
_invitesServiceMock = new Mock<IInvitesService>();
_jwtService = new JwtService(
_jwtOptionsMock.Object,
_jwtRefreshOptionsMock.Object,
_invitesServiceMock.Object);
}
[Test]
public async Task GenerateJwtToken_ShouldReturnValidJwtString_WithCorrectClaims()
{
// Arrange
var user = _fixture.Create<User>();
var sessionId = Guid.NewGuid();
var expectedRole = "User";
_invitesServiceMock.Setup(s => s.GetRoleNameAsync(user)).ReturnsAsync(expectedRole);
// Act
var tokenString = await _jwtService.GenerateAccessTokenAsync(user, sessionId);
// Assert
var handler = new JwtSecurityTokenHandler();
var jwt = handler.ReadJwtToken(tokenString);
var claims = jwt.Claims.ToDictionary(c => c.Type, c => c.Value);
Assert.That(claims["userId"], Is.EqualTo(user.Id.ToString()));
Assert.That(claims["sid"], Is.EqualTo(sessionId.ToString()));
Assert.That(claims[ClaimTypes.Role], Is.EqualTo(expectedRole));
Assert.That(jwt.ValidTo, Is.GreaterThan(DateTime.UtcNow));
}
[Test]
public async Task GenerateAccessTokenAsync_ShouldIncludeSessionIdAndRole()
{
// Arrange
var user = new User { Id = Guid.NewGuid(), Username = "TestUser" };
var sessionId = Guid.NewGuid();
var role = "Admin";
_invitesServiceMock.Setup(s => s.GetRoleNameAsync(user)).ReturnsAsync(role);
// Act
var token = await _jwtService.GenerateAccessTokenAsync(user, sessionId);
var handler = new JwtSecurityTokenHandler();
var jwt = handler.ReadJwtToken(token);
// Assert
var sidClaim = jwt.Claims.FirstOrDefault(c => c.Type == "sid");
var roleClaim = jwt.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Role);
Assert.That(sidClaim?.Value, Is.EqualTo(sessionId.ToString()));
Assert.That(roleClaim?.Value, Is.EqualTo(role));
}
[Test]
public async Task GenerateRefreshTokenAsync_ReturnsValidRefreshToken()
{
// Arrange
var user = new User { Id = Guid.NewGuid() };
// Act
var token = await _jwtService.GenerateRefreshTokenAsync(user);
// Assert
Assert.That(token, Is.Not.Null);
var handler = new JwtSecurityTokenHandler();
var jwt = handler.ReadJwtToken(token);
Assert.That(user.Id.ToString(), Is.EqualTo(jwt.Claims.First(c => c.Type == "userId").Value));
Assert.That("refresh",Is.EqualTo(jwt.Claims.First(c => c.Type == "tokenType").Value));
}
[Test]
public async Task GetPrincipalFromExpiredToken_ReturnsValidClaimsPrincipal()
{
// Arrange
var userId = Guid.NewGuid();
var handler = new JwtSecurityTokenHandler();
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_testJwtAccessOptions.SecretKey));
var now = DateTime.UtcNow;
var token = handler.CreateToken(new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new[]
{
new Claim("userId", userId.ToString())
}),
NotBefore = now.AddSeconds(-10),
IssuedAt = now.AddSeconds(-10),
Expires = now.AddSeconds(-5),
SigningCredentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256)
});
var expiredToken = handler.WriteToken(token);
// Act
var principal = _jwtService.GetPrincipalFromExpiredToken(expiredToken);
// Assert
Assert.That(principal, Is.Not.Null);
var claim = principal.FindFirst("userId");
Assert.That(claim, Is.Not.Null);
Assert.That(userId.ToString(), Is.EqualTo(claim.Value));
}
}
@@ -0,0 +1,93 @@
using AutoFixture;
using Microsoft.Extensions.Configuration;
[TestFixture]
public class JwtTokenHasherTests
{
private IJwtTokenHasher _jwtTokenHasher = null!;
private Fixture _fixture = null!;
private const string TestSecret = "SuperSecretPepper123!";
[SetUp]
public void StartUp()
{
_fixture = new Fixture();
var config = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary<string, string?>
{
{ "EncryptionOption:Secret", TestSecret }
})
.Build();
_jwtTokenHasher = new JwtTokenHasher(config);
}
[Test]
public void Given_Token_When_Hash_Then_Verify_Should_Return_True()
{
// Arrange
string token = _fixture.Create<string>();
// Act
string hash = _jwtTokenHasher.HashToken(token);
var result = _jwtTokenHasher.VerifyToken(token, hash);
// Assert
Assert.That(hash, Is.Not.EqualTo(token));
Assert.That(result, Is.True);
}
[Test]
public void Given_Invalid_Token_When_Verify_Should_Return_False()
{
// Arrange
string token = _fixture.Create<string>();
string notToken = _fixture.Create<string>();
// Act
string hash = _jwtTokenHasher.HashToken(token);
var result = _jwtTokenHasher.VerifyToken(notToken, hash);
// Assert
Assert.That(result, Is.False);
}
[Test]
public void Given_Same_Token_When_Hash_Multiple_Times_Should_Be_Equal()
{
// Arrange
string token = _fixture.Create<string>();
// Act
string hash1 = _jwtTokenHasher.HashToken(token);
string hash2 = _jwtTokenHasher.HashToken(token);
// Assert
Assert.That(hash1, Is.EqualTo(hash2));
}
[Test]
public void Given_Different_Tokens_When_Hash_Should_Be_Different()
{
// Arrange
string token1 = _fixture.Create<string>();
string token2 = _fixture.Create<string>();
// Act
string hash1 = _jwtTokenHasher.HashToken(token1);
string hash2 = _jwtTokenHasher.HashToken(token2);
// Assert
Assert.That(hash1, Is.Not.EqualTo(hash2));
}
[Test]
public void Given_Null_Secret_In_Config_Should_Use_Default_Secret()
{
// Arrange
var emptyConfig = new ConfigurationBuilder().Build();
// Act & Assert
Assert.Throws<InvalidOperationException>(() => new JwtTokenHasher(emptyConfig));
}
}
@@ -0,0 +1,48 @@
using AutoFixture;
namespace Govor.Application.Tests.Services;
[TestFixture]
public class PasswordHasherTests
{
private IPasswordHasher _passwordHasher = null!;
private Fixture _fixture = null!;
[SetUp]
public void StarUp()
{
_fixture = new Fixture();
_passwordHasher = new PasswordHasher();
}
[Test]
public void Given_Password_When_Hash_Then_Hash_And_Verify_Then_Result_Should_Be_True()
{
// Arrange
string password = _fixture.Create<string>();
// Act
string hash = _passwordHasher.Hash(password);
var result = _passwordHasher.Verify(password, hash);
// Assert
Assert.That(hash, Is.Not.EqualTo(password));
Assert.That(result, Is.True);
}
[Test]
public void Given_Password_NotPassword_When_Hash_Should_Not_Be_True_Then_Result_Should_Be_False()
{
// Arrange
string password = _fixture.Create<string>();
string notPassword = _fixture.Create<string>();
// Act
string hash = _passwordHasher.Hash(password);
var result = _passwordHasher.Verify(notPassword, hash);
// Assert
Assert.That(result, Is.False);
}
}
@@ -0,0 +1,105 @@
using System.Security.Claims;
using Govor.Application.Infrastructure.Extensions;
using Microsoft.AspNetCore.Http;
using Moq;
namespace Govor.Application.Tests.Infrastructure.Extensions;
[TestFixture]
public class CurrentUserServiceTests
{
private Mock<IHttpContextAccessor> _httpContextAccessorMock = null!;
private ICurrentUserService _currentUserService = null!;
[SetUp]
public void SetUp()
{
_httpContextAccessorMock = new Mock<IHttpContextAccessor>();
_currentUserService = new CurrentUserService(_httpContextAccessorMock.Object);
}
[Test]
public void GetCurrentUserId_ValidUserIdClaim_ReturnsGuid()
{
// Arrange
var userId = Guid.NewGuid();
var claims = new[] { new Claim("userId", userId.ToString()) };
var identity = new ClaimsIdentity(claims);
var principal = new ClaimsPrincipal(identity);
var httpContextMock = new Mock<HttpContext>();
httpContextMock.Setup(x => x.User).Returns(principal);
_httpContextAccessorMock.Setup(x => x.HttpContext).Returns(httpContextMock.Object);
// Act
var result = _currentUserService.GetCurrentUserId();
// Assert
Assert.That(result, Is.EqualTo(userId));
}
[Test]
public void GetCurrentUserId_NoHttpContext_ThrowsUnauthorizedAccessException()
{
// Arrange
_httpContextAccessorMock.Setup(x => x.HttpContext).Returns((HttpContext)null);
// Act & Assert
var ex = Assert.Throws<UnauthorizedAccessException>(() => _currentUserService.GetCurrentUserId());
Assert.That(ex.Message, Is.EqualTo("userID claim is missing or invalid"));
}
[Test]
public void GetCurrentUserId_NoUserIdClaim_ThrowsUnauthorizedAccessException()
{
// Arrange
var claims = new[] { new Claim("otherClaim", "value") };
var identity = new ClaimsIdentity(claims);
var principal = new ClaimsPrincipal(identity);
var httpContextMock = new Mock<HttpContext>();
httpContextMock.Setup(x => x.User).Returns(principal);
_httpContextAccessorMock.Setup(x => x.HttpContext).Returns(httpContextMock.Object);
// Act & Assert
var ex = Assert.Throws<UnauthorizedAccessException>(() => _currentUserService.GetCurrentUserId());
Assert.That(ex.Message, Is.EqualTo("userID claim is missing or invalid"));
}
[Test]
public void GetCurrentUserId_InvalidUserIdClaim_ThrowsUnauthorizedAccessException()
{
// Arrange
var claims = new[] { new Claim("userId", "invalid-guid") };
var identity = new ClaimsIdentity(claims);
var principal = new ClaimsPrincipal(identity);
var httpContextMock = new Mock<HttpContext>();
httpContextMock.Setup(x => x.User).Returns(principal);
_httpContextAccessorMock.Setup(x => x.HttpContext).Returns(httpContextMock.Object);
// Act & Assert
var ex = Assert.Throws<UnauthorizedAccessException>(() => _currentUserService.GetCurrentUserId());
Assert.That(ex.Message, Is.EqualTo("userID claim is missing or invalid"));
}
[Test]
public void GetCurrentUserId_EmptyUserIdClaim_ThrowsUnauthorizedAccessException()
{
// Arrange
var claims = new[] { new Claim("userId", "") };
var identity = new ClaimsIdentity(claims);
var principal = new ClaimsPrincipal(identity);
var httpContextMock = new Mock<HttpContext>();
httpContextMock.Setup(x => x.User).Returns(principal);
_httpContextAccessorMock.Setup(x => x.HttpContext).Returns(httpContextMock.Object);
// Act & Assert
var ex = Assert.Throws<UnauthorizedAccessException>(() => _currentUserService.GetCurrentUserId());
Assert.That(ex.Message, Is.EqualTo("userID claim is missing or invalid"));
}
}
@@ -0,0 +1,107 @@
using System.Security.Claims;
using Govor.Application.Infrastructure.Extensions;
using Microsoft.AspNetCore.Http;
using Moq;
namespace Govor.Application.Tests.Infrastructure.Extensions;
[TestFixture]
[TestOf(typeof(CurrentUserSessionService))]
public class CurrentUserSessionServiceTests
{
private Mock<IHttpContextAccessor> _httpContextAccessorMock = null!;
private ICurrentUserSessionService _sessionService = null!;
[SetUp]
public void SetUp()
{
_httpContextAccessorMock = new Mock<IHttpContextAccessor>();
_sessionService = new CurrentUserSessionService(_httpContextAccessorMock.Object);
}
[Test]
public void GetCurrentSessionId_ValidSidClaim_ReturnsGuid()
{
// Arrange
var sid = Guid.NewGuid();
var claims = new[] { new Claim("sid", sid.ToString()) };
var identity = new ClaimsIdentity(claims);
var principal = new ClaimsPrincipal(identity);
var httpContextMock = new Mock<HttpContext>();
httpContextMock.Setup(x => x.User).Returns(principal);
_httpContextAccessorMock.Setup(x => x.HttpContext).Returns(httpContextMock.Object);
// Act
var result = _sessionService.GetUserSessionId();
// Assert
Assert.That(result, Is.EqualTo(sid));
}
[Test]
public void GetCurrentSessionId_NoHttpContext_ThrowsUnauthorizedAccessException()
{
// Arrange
_httpContextAccessorMock.Setup(x => x.HttpContext).Returns((HttpContext)null);
// Act & Assert
var ex = Assert.Throws<UnauthorizedAccessException>(() => _sessionService.GetUserSessionId());
Assert.That(ex.Message, Is.EqualTo("Session id (sid) claim is missing or invalid"));
}
[Test]
public void GetCurrentSessionId_NoSidlaim_ThrowsUnauthorizedAccessException()
{
// Arrange
var claims = new[] { new Claim("otherClaim", "value") };
var identity = new ClaimsIdentity(claims);
var principal = new ClaimsPrincipal(identity);
var httpContextMock = new Mock<HttpContext>();
httpContextMock.Setup(x => x.User).Returns(principal);
_httpContextAccessorMock.Setup(x => x.HttpContext).Returns(httpContextMock.Object);
// Act & Assert
var ex = Assert.Throws<UnauthorizedAccessException>(() => _sessionService.GetUserSessionId());
Assert.That(ex.Message, Is.EqualTo("Session id (sid) claim is missing or invalid"));
}
[Test]
public void GetUserSessionId_InvalidSidValueClaim_ThrowsUnauthorizedAccessException()
{
// Arrange
var claims = new[] { new Claim("sid", "invalid-guid") };
var identity = new ClaimsIdentity(claims);
var principal = new ClaimsPrincipal(identity);
var httpContextMock = new Mock<HttpContext>();
httpContextMock.Setup(x => x.User).Returns(principal);
_httpContextAccessorMock.Setup(x => x.HttpContext).Returns(httpContextMock.Object);
// Act & Assert
var ex = Assert.Throws<UnauthorizedAccessException>(() => _sessionService.GetUserSessionId());
Assert.That(ex.Message, Is.EqualTo("Session id (sid) claim is missing or invalid"));
}
[Test]
public void GetUserSessionId_EmptySidValueClaim_ThrowsUnauthorizedAccessException()
{
// Arrange
var claims = new[] { new Claim("sid", "") };
var identity = new ClaimsIdentity(claims);
var principal = new ClaimsPrincipal(identity);
var httpContextMock = new Mock<HttpContext>();
httpContextMock.Setup(x => x.User).Returns(principal);
_httpContextAccessorMock.Setup(x => x.HttpContext).Returns(httpContextMock.Object);
// Act & Assert
var ex = Assert.Throws<UnauthorizedAccessException>(() => _sessionService.GetUserSessionId());
Assert.That(ex.Message, Is.EqualTo("Session id (sid) claim is missing or invalid"));
}
}
@@ -0,0 +1,52 @@
using Govor.Domain.Common;
using Microsoft.Extensions.Configuration;
namespace Govor.Application.Tests.Unit.Infrastructure.Validators;
[TestFixture]
public class UsernameBoundaryTests
{
private static Dictionary<string, string?> Settings() => new()
{
["UsernameModeration:BlockedExact:0"] = "админ",
["UsernameModeration:BlockedContains:0"] = "запрет",
["UsernameModeration:Reserved:0"] = "логин"
};
private static UsernameValidator Validator() => new(new ConfigurationBuilder().AddInMemoryCollection(Settings()).Build());
[Test]
public void NameLengthBoundariesAndNullReturnValidationResults()
{
var validator = Validator();
var longest = string.Concat(Enumerable.Repeat("Иван", 11));
Assert.That(validator.Validate("Иван").IsSuccess, Is.True);
Assert.That(validator.Validate(longest).IsSuccess, Is.True);
foreach (var invalid in new[] { null, "", " ", "Ива", longest + "а" })
{
var result = validator.Validate(invalid!);
Assert.That(result.IsFailure, Is.True);
Assert.That(result.Error.Type, Is.EqualTo(ErrorType.Validation));
Assert.That(validator.TryValidate(invalid!), Is.False);
}
}
[TestCase("Абббб", true)]
[TestCase("Аббббб", false)]
[TestCase("Иван0", true)]
[TestCase("Админ", false)]
[TestCase("ЛОГИН", false)]
[TestCase("Запрет123", false)]
public void SyntaxRepetitionAndModerationAreApplied(string name, bool valid) =>
Assert.That(Validator().Validate(name).IsSuccess, Is.EqualTo(valid));
[TestCase("BlockedExact")]
[TestCase("BlockedContains")]
[TestCase("Reserved")]
public void MissingModerationSectionFailsConfiguration(string section)
{
var settings = Settings();
settings.Remove("UsernameModeration:" + section + ":0");
Assert.Throws<InvalidOperationException>(() => new UsernameValidator(new ConfigurationBuilder().AddInMemoryCollection(settings).Build()));
}
}
@@ -0,0 +1,107 @@
using Govor.Application.Authentication.Exceptions;
using Govor.Application.Infrastructure.Validators;
using Microsoft.Extensions.Configuration;
namespace Govor.Application.Tests.Infrastructure.Validators;
[TestFixture]
public class UsernameValidatorTests
{
private UsernameValidator _validator = null!;
[SetUp]
public void SetUp()
{
var configData = new Dictionary<string, string?>
{
["UsernameModeration:BlockedExact:0"] = "админ",
["UsernameModeration:BlockedExact:1"] = "модератор",
["UsernameModeration:BlockedContains:0"] = "гитлер",
["UsernameModeration:BlockedContains:1"] = "наци",
["UsernameModeration:Reserved:0"] = "логин",
["UsernameModeration:Reserved:1"] = "регистрация"
};
var config = new ConfigurationBuilder()
.AddInMemoryCollection(configData)
.Build();
_validator = new UsernameValidator(config);
}
[TestCase("Иван")]
[TestCase("Алексей")]
[TestCase("Ёжик")]
[TestCase("Иван123")] // содержит цифры
public void Validate_ValidUsernames_ReturnsSuccess(string username)
{
Assert.That(_validator.Validate(username).IsSuccess, Is.True);
}
[TestCase("Ivan")] // не кириллица
[TestCase("123Иван")] // начинается не с буквы
[TestCase("!@#$")] // спецсимволы
[TestCase("")] // пусто
[TestCase("И")] // меньше минимума
[TestCase("ИванИванИванИванИванИванИванИванИванИванИванИванИван")] // больше максимума (44 символа)
public void Validate_InvalidUsernames_ReturnsFailure(string username)
{
var result = _validator.Validate(username);
Assert.That(result.IsFailure, Is.True);
Assert.That(result.Error.Type, Is.EqualTo(Govor.Domain.Common.ErrorType.Validation));
}
[TestCase("Ааааааа")]
[TestCase("Бbbbb")]
public void Validate_RepeatingCharacters_ReturnsFailure(string username)
{
var result = _validator.Validate(username);
Assert.That(result.IsFailure, Is.True);
Assert.That(result.Error.Type, Is.EqualTo(Govor.Domain.Common.ErrorType.Validation));
}
[TestCase("Админ")]
[TestCase("Модератор")]
public void Validate_BlockedExact_ReturnsFailure(string username)
{
var result = _validator.Validate(username);
Assert.That(result.IsFailure, Is.True);
Assert.That(result.Error.Type, Is.EqualTo(Govor.Domain.Common.ErrorType.Validation));
}
[TestCase("Гитлер123")]
[TestCase("Нацист")]
public void Validate_BlockedContains_ReturnsFailure(string username)
{
var result = _validator.Validate(username);
Assert.That(result.IsFailure, Is.True);
Assert.That(result.Error.Type, Is.EqualTo(Govor.Domain.Common.ErrorType.Validation));
}
[TestCase("Логин")]
[TestCase("Регистрация")]
public void Validate_ReservedNames_ReturnsFailure(string username)
{
var result = _validator.Validate(username);
Assert.That(result.IsFailure, Is.True);
Assert.That(result.Error.Type, Is.EqualTo(Govor.Domain.Common.ErrorType.Validation));
}
[TestCase("Г1тлер")]
public void Validate_Normalization_ShouldDetectBlockedWord(string username)
{
var result = _validator.Validate(username);
Assert.That(result.IsFailure, Is.True);
Assert.That(result.Error.Type, Is.EqualTo(Govor.Domain.Common.ErrorType.Validation));
}
[TestCase("Иван", ExpectedResult = true)]
[TestCase("1234", ExpectedResult = false)]
[TestCase("Админ", ExpectedResult = false)]
[TestCase("Гитлер123", ExpectedResult = false)]
public bool TryValidate_ShouldReturnExpectedResult(string username)
{
return _validator.TryValidate(username);
}
}
@@ -0,0 +1,147 @@
using Govor.Application.PushNotifications;
using Govor.Application.PushNotifications.Providers;
using Govor.Application.Interfaces.PushNotifications.Models;
using Govor.Domain.Common;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Application.Tests.Unit.PushNotifications;
[TestFixture]
public class PushNotificationServiceTests
{
private Mock<IPushNotificationProvider> _provider = null!;
private Mock<IPushTokenService> _tokens = null!;
private PushNotificationService _service = null!;
private readonly Guid _recipient = Guid.NewGuid();
private static readonly Error Failure = Error.ServerError("Test.Failure", "unavailable");
[SetUp]
public void SetUp()
{
_provider = new Mock<IPushNotificationProvider>(MockBehavior.Strict);
_tokens = new Mock<IPushTokenService>(MockBehavior.Strict);
_service = new(_provider.Object, _tokens.Object, NullLogger<PushNotificationService>.Instance);
}
[Test]
public async Task TokenLookupErrorsAreReturnedWithoutSending()
{
_tokens.Setup(t => t.GetStringsActiveTokensAsync(_recipient)).ReturnsAsync(Result.Failure<List<string>>(Failure));
_tokens.Setup(t => t.GetUsersStringsActiveTokensAsync(It.IsAny<IEnumerable<Guid>>())).ReturnsAsync(Result.Failure<List<string>>(Failure));
_tokens.Setup(t => t.GetActiveTokenBySessionAsync(_recipient)).ReturnsAsync(Result.Failure<string?>(Failure));
Assert.That((await _service.SendToUserAsync(_recipient, "t", "b", "c")).Error, Is.SameAs(Failure));
Assert.That((await _service.SendToUsersAsync(new[] { _recipient }, "t", "b", "c")).Error, Is.SameAs(Failure));
Assert.That((await _service.SendToSessionAsync(_recipient, "t", "b", "c")).Error, Is.SameAs(Failure));
_provider.VerifyNoOtherCalls();
}
[Test]
public async Task MissingTokensAreSuccessfulNoOpsForEveryDeliveryMode()
{
_tokens.Setup(t => t.GetStringsActiveTokensAsync(_recipient)).ReturnsAsync(new List<string>());
_tokens.Setup(t => t.GetUsersStringsActiveTokensAsync(It.IsAny<IEnumerable<Guid>>())).ReturnsAsync(new List<string>());
_tokens.Setup(t => t.GetActiveTokenBySessionAsync(_recipient)).ReturnsAsync((string?)null);
Assert.That((await _service.SendToUserAsync(_recipient, "t", "b", "c")).IsSuccess, Is.True);
Assert.That((await _service.SendToUsersAsync(new[] { _recipient }, "t", "b", "c")).IsSuccess, Is.True);
Assert.That((await _service.SendToSessionAsync(_recipient, "t", "b", "c")).IsSuccess, Is.True);
_provider.VerifyNoOtherCalls();
}
[Test]
public async Task EmptyOrNullBulkRecipientsAreRejectedBeforeTokenLookup()
{
Assert.That((await _service.SendToUsersAsync(Array.Empty<Guid>(), "t", "b", "c")).Error.Code, Is.EqualTo("Push.InvalidArgs"));
Assert.That((await _service.SendToUsersAsync(null!, "t", "b", "c")).IsFailure, Is.True);
_tokens.VerifyNoOtherCalls();
_provider.VerifyNoOtherCalls();
}
[Test]
public async Task SessionDeliveryPreservesPayload()
{
var data = new Dictionary<string, string> { ["id"] = "message" };
_tokens.Setup(t => t.GetActiveTokenBySessionAsync(_recipient)).ReturnsAsync("device");
_provider.Setup(p => p.SendToTokenAsync("device", It.Is<PushMessage>(m => m.Title == "title" &&
m.Body == "body" && m.ChannelId == "channel" && m.Tag == "tag" && m.Data == data)))
.ReturnsAsync(new SendPushResult(1, 0, Array.Empty<string>()));
Assert.That((await _service.SendToSessionAsync(_recipient, "title", "body", "channel", "tag", data)).IsSuccess, Is.True);
_provider.VerifyAll();
}
[Test]
public async Task SessionProviderExceptionBecomesFailureAndKeepsToken()
{
_tokens.Setup(t => t.GetActiveTokenBySessionAsync(_recipient)).ReturnsAsync("device");
_provider.Setup(p => p.SendToTokenAsync("device", It.IsAny<PushMessage>())).ThrowsAsync(new IOException("provider offline"));
Assert.That((await _service.SendToSessionAsync(_recipient, "t", "b", "c")).IsFailure, Is.True);
_tokens.Verify(t => t.RemoveTokensAsync(It.IsAny<IEnumerable<string>>()), Times.Never);
}
[Test]
public async Task BulkRecipientsAndTokensAreDeduplicatedAndBatchingContinuesAfterFailure()
{
var tokens = Enumerable.Range(0, 501).Select(i => "device-" + i).ToList();
tokens.Add(tokens[0]);
_tokens.Setup(t => t.GetUsersStringsActiveTokensAsync(It.Is<IEnumerable<Guid>>(ids => ids.SequenceEqual(new[] { _recipient }))))
.ReturnsAsync(tokens);
var batches = new List<int>();
_provider.Setup(p => p.SendMulticastAsync(It.IsAny<IReadOnlyList<string>>(), It.IsAny<PushMessage>()))
.Returns((IReadOnlyList<string> batch, PushMessage message) =>
{
batches.Add(batch.Count);
Assert.That(message.Data, Is.Empty);
return batches.Count == 1 ? Task.FromException<SendPushResult>(new IOException("offline")) :
Task.FromResult(new SendPushResult(batch.Count, 0, Array.Empty<string>()));
});
var result = await _service.SendToUsersAsync(new[] { _recipient, _recipient }, "t", "b", "c");
Assert.That(result.Error.Code, Is.EqualTo("Push.DeliveryFailed"));
Assert.That(batches, Is.EqualTo(new[] { 500, 1 }));
_tokens.Verify(t => t.RemoveTokensAsync(It.IsAny<IEnumerable<string>>()), Times.Never);
}
[Test]
public async Task OnlyUnregisteredTokensFromThisBatchCanBeRemoved()
{
_tokens.Setup(t => t.GetStringsActiveTokensAsync(_recipient)).ReturnsAsync(new List<string> { "valid", "gone" });
_provider.Setup(p => p.SendMulticastAsync(It.IsAny<IReadOnlyList<string>>(), It.IsAny<PushMessage>()))
.ReturnsAsync(new SendPushResult(1, 1, new[] { "gone", "gone", "unrelated" }));
_tokens.Setup(t => t.RemoveTokensAsync(It.Is<IEnumerable<string>>(ts => ts.SequenceEqual(new[] { "gone" }))))
.ReturnsAsync(Result.Success());
Assert.That((await _service.SendToUserAsync(_recipient, "t", "b", "c")).IsSuccess, Is.True);
_tokens.VerifyAll();
}
[Test]
public async Task TokenRemovalFailureIsPropagated()
{
_tokens.Setup(t => t.GetActiveTokenBySessionAsync(_recipient)).ReturnsAsync("gone");
_provider.Setup(p => p.SendToTokenAsync("gone", It.IsAny<PushMessage>())).ReturnsAsync(new SendPushResult(0, 1, new[] { "gone" }));
_tokens.Setup(t => t.RemoveTokensAsync(It.IsAny<IEnumerable<string>>())).ReturnsAsync(Result.Failure(Failure));
Assert.That((await _service.SendToSessionAsync(_recipient, "t", "b", "c")).Error, Is.SameAs(Failure));
}
[TestCase(0, 0)]
[TestCase(0, 1)]
[TestCase(2, 0)]
public async Task IncompleteOrInconsistentProviderCountsAreFailures(int success, int failed)
{
_tokens.Setup(t => t.GetActiveTokenBySessionAsync(_recipient)).ReturnsAsync("device");
_provider.Setup(p => p.SendToTokenAsync("device", It.IsAny<PushMessage>()))
.ReturnsAsync(new SendPushResult(success, failed, Array.Empty<string>()));
Assert.That((await _service.SendToSessionAsync(_recipient, "t", "b", "c")).Error.Code, Is.EqualTo("Push.DeliveryFailed"));
}
[Test]
public async Task NullProviderAcceptsSingleAndMulticastWithoutNetwork()
{
var provider = new NullPushProvider();
Assert.That(provider.Name, Is.EqualTo("NULL"));
Assert.That((await provider.SendToTokenAsync("device", new PushMessage())).SuccessCount, Is.EqualTo(1));
var result = await provider.SendMulticastAsync(new[] { "a", "b" }, new PushMessage());
Assert.That(result.SuccessCount, Is.EqualTo(2));
Assert.That(result.FailureCount, Is.Zero);
Assert.That(result.FailedTokens, Is.Empty);
}
}
@@ -0,0 +1,187 @@
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using Govor.Application.E2ee;
using Jose;
namespace Govor.Application.Tests.Unit.Security;
[TestFixture]
public class E2eeProtocolBoundaryTests
{
private DevicePrivateKeys _keys = null!;
private DeviceKey _device = null!;
private ConversationKeys _conversation = null!;
private Guid _message;
[OneTimeSetUp]
public void SetUp()
{
_keys = E2eeProtocol.GenerateKeys();
_device = E2eeProtocol.PublicKey(_keys, Guid.NewGuid(), Guid.NewGuid());
_conversation = new(Guid.NewGuid(), 0, new[] { _device.UserId }, new[] { _device });
_message = Guid.NewGuid();
}
private string Encrypt() => E2eeProtocol.Encrypt(new("secret", []), _keys, _device, _conversation, _message);
private string Sign(EncryptedMessage envelope)
{
using var signing = ECDsa.Create();
signing.ImportPkcs8PrivateKey(Convert.FromBase64String(_keys.IdentityKey), out _);
return E2eeProtocol.Prefix + JWT.Encode(JsonSerializer.Serialize(envelope), signing, JwsAlgorithm.ES256);
}
[TestCase("plaintext")]
[TestCase("too-large")]
[TestCase("segments")]
[TestCase("null-json")]
public void InspectRejectsInvalidEnvelopeBeforeTrustingPayload(string reason)
{
var input = reason switch {
"plaintext" => "secret",
"too-large" => E2eeProtocol.Prefix + new string('x', E2eeProtocol.MaxEnvelopeLength),
"segments" => E2eeProtocol.Prefix + "only.two",
_ => E2eeProtocol.Prefix + "header." + Base64Url.Encode("null"u8.ToArray()) + ".signature"
};
Assert.Throws<CryptographicException>(() => E2eeProtocol.Inspect(input));
}
[TestCase("version")]
[TestCase("sender")]
[TestCase("message")]
[TestCase("conversation")]
[TestCase("type")]
[TestCase("recipients")]
[TestCase("media")]
[TestCase("ciphertext")]
public void InspectRejectsInvalidRoutingFields(string field)
{
var envelope = E2eeProtocol.Inspect(Encrypt());
envelope = field switch {
"version" => envelope with { Version = 2 },
"sender" => envelope with { Sender = null! },
"message" => envelope with { MessageId = Guid.Empty },
"conversation" => envelope with { ConversationId = Guid.Empty },
"type" => envelope with { RecipientType = 2 },
"recipients" => envelope with { Recipients = [] },
"media" => envelope with { MediaIds = null! },
_ => envelope with { Ciphertext = "" }
};
Assert.Throws<CryptographicException>(() => E2eeProtocol.Inspect(Sign(envelope)));
}
[TestCase("empty-message")]
[TestCase("empty-content")]
[TestCase("long-text")]
[TestCase("null-attachments")]
[TestCase("many-attachments")]
[TestCase("no-devices")]
[TestCase("many-devices")]
public void EncryptEnforcesContentAndRecipientLimits(string reason)
{
var plaintext = reason switch {
"empty-content" => new MessagePlaintext(" ", []),
"long-text" => new MessagePlaintext(new string('x', 20_001), []),
"null-attachments" => new MessagePlaintext("secret", null!),
"many-attachments" => new MessagePlaintext("secret", Enumerable.Range(0, 101)
.Select(_ => new AttachmentSecret(Guid.NewGuid(), "key", "file", "type")).ToArray()),
_ => new MessagePlaintext("secret", [])
};
var directory = reason == "no-devices" ? _conversation with { Devices = [] } :
reason == "many-devices" ? _conversation with { Devices = Enumerable.Repeat(_device, 501).ToArray() } : _conversation;
Assert.Throws<CryptographicException>(() => E2eeProtocol.Encrypt(plaintext, _keys, _device, directory,
reason == "empty-message" ? Guid.Empty : _message));
}
[TestCase("unprotected")]
[TestCase("aad")]
[TestCase("compression")]
[TestCase("encryption")]
[TestCase("manifest")]
[TestCase("algorithm")]
public void ValidSignatureDoesNotAuthorizeUnsupportedEncryptionHeaders(string reason)
{
var envelope = E2eeProtocol.Inspect(Encrypt());
var jwe = JsonNode.Parse(envelope.Ciphertext)!;
if (reason is "unprotected" or "aad") jwe[reason] = reason == "aad" ? JsonValue.Create("value") : new JsonObject();
if (reason is "compression" or "encryption")
{
var header = JsonNode.Parse(Base64Url.Decode(jwe["protected"]!.GetValue<string>()))!;
if (reason == "compression") header["zip"] = "DEF"; else header["enc"] = "A128GCM";
jwe["protected"] = Base64Url.Encode(Encoding.UTF8.GetBytes(header.ToJsonString()));
}
if (reason == "algorithm")
{
var recipient = jwe["recipients"] is JsonArray recipients ? recipients[0]! : jwe;
recipient["header"]!["alg"] = "RSA1_5";
}
if (reason == "manifest") envelope = envelope with { Recipients = new[] { "wrong-fingerprint" } };
var signed = Sign(envelope with { Ciphertext = jwe.ToJsonString() });
Assert.Throws<CryptographicException>(() => E2eeProtocol.Verify(signed));
}
[Test]
public void RecipientTypeAndEditContextAreAuthenticated()
{
var encrypted = Encrypt();
Assert.Throws<CryptographicException>(() => E2eeProtocol.Decrypt(encrypted, _keys, _message,
_conversation.ConversationId, 1, _device.UserId));
Assert.Throws<CryptographicException>(() => E2eeProtocol.Decrypt(encrypted, _keys, _message,
_conversation.ConversationId, 0, _device.UserId, expectedEdit: true));
}
[TestCase("identity")]
[TestCase("encryption")]
[TestCase("trailing-identity")]
[TestCase("trailing-encryption")]
[TestCase("empty-user")]
[TestCase("empty-session")]
public void InvalidDevicePublicKeysAreRejected(string reason)
{
var bad = reason switch {
"identity" => _device with { IdentityKey = "AAAA" },
"encryption" => _device with { EncryptionKey = "AAAA" },
"trailing-identity" => _device with { IdentityKey = Convert.ToBase64String(Convert.FromBase64String(_device.IdentityKey).Concat(new byte[] { 1 }).ToArray()) },
"trailing-encryption" => _device with { EncryptionKey = Convert.ToBase64String(Convert.FromBase64String(_device.EncryptionKey).Concat(new byte[] { 1 }).ToArray()) },
"empty-user" => _device with { UserId = Guid.Empty },
_ => _device with { SessionId = Guid.Empty }
};
Assert.Throws<CryptographicException>(() => E2eeProtocol.ValidatePublicKey(bad));
}
[Test]
public void InvalidPrivateKeysDoNotProducePublicKeys()
{
Assert.Throws<CryptographicException>(() => E2eeProtocol.PublicKey(_keys with { IdentityKey = "AAAA" }, _device.UserId, _device.SessionId));
Assert.Throws<CryptographicException>(() => E2eeProtocol.PublicKey(_keys with { EncryptionKey = "AAAA" }, _device.UserId, _device.SessionId));
}
[TestCase("short")]
[TestCase("large")]
[TestCase("key")]
public void AttachmentsEnforceCiphertextSizeAndKeyLength(string reason)
{
if (reason == "large") Assert.Throws<CryptographicException>(() => E2eeProtocol.EncryptAttachment(new byte[19_000_001]));
else if (reason == "short") Assert.Throws<CryptographicException>(() => E2eeProtocol.DecryptAttachment(new byte[27], Convert.ToBase64String(new byte[32])));
else
{
var (encrypted, _) = E2eeProtocol.EncryptAttachment(new byte[] { 1 });
Assert.Throws<CryptographicException>(() => E2eeProtocol.DecryptAttachment(encrypted, Convert.ToBase64String(new byte[16])));
}
}
[TestCase("null")]
[TestCase("{\"Text\":null,\"Attachments\":[]}")]
[TestCase("{\"Text\":\"secret\",\"Attachments\":[{\"MediaId\":\"11111111-1111-1111-1111-111111111111\"}]}")]
public void DecryptionRejectsMalformedPlaintextOrAttachmentManifest(string plaintext)
{
using var rsa = RSA.Create();
rsa.ImportSubjectPublicKeyInfo(Convert.FromBase64String(_device.EncryptionKey), out _);
var ciphertext = JWE.Encrypt(plaintext, new[] { new JweRecipient(JweAlgorithm.RSA_OAEP_256, rsa,
new Dictionary<string, object> { ["kid"] = _device.Fingerprint }) }, JweEncryption.A256GCM);
var envelope = E2eeProtocol.Inspect(Encrypt()) with { Ciphertext = ciphertext };
Assert.Throws<CryptographicException>(() => E2eeProtocol.Decrypt(Sign(envelope), _keys, _message,
_conversation.ConversationId, 0, _device.UserId));
}
}
@@ -0,0 +1,78 @@
namespace Govor.Application.Tests.Unit.Storage;
[TestFixture]
public class LocalStorageBoundaryTests
{
private string _root = null!;
private LocalStorageService _service = null!;
[SetUp]
public void SetUp()
{
_root = Path.Combine(Path.GetTempPath(), "govor-storage-tests-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(_root);
_service = new(_root);
}
[TearDown]
public void TearDown()
{
var resolved = Path.GetFullPath(_root);
if (!resolved.StartsWith(Path.GetFullPath(Path.GetTempPath()), StringComparison.OrdinalIgnoreCase) ||
!Path.GetFileName(resolved).StartsWith("govor-storage-tests-", StringComparison.Ordinal))
throw new InvalidOperationException("Unexpected temporary storage path.");
Directory.Delete(resolved, recursive: true);
}
[TestCase("../uploads-sibling/secret.bin")]
[TestCase("../outside.bin")]
public async Task TraversalCannotReadOrDeleteFilesOutsideUploadRoot(string relative)
{
var target = Path.GetFullPath(Path.Combine(_root, "uploads", relative));
Directory.CreateDirectory(Path.GetDirectoryName(target)!);
await File.WriteAllTextAsync(target, "secret");
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _service.LoadAsync(relative));
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _service.RemoveAsync(relative));
Assert.That(await File.ReadAllTextAsync(target), Is.EqualTo("secret"));
}
[Test]
public async Task AbsolutePathsAreRejectedEvenInsideStorage()
{
var absolute = Path.Combine(_root, "uploads", "absolute.bin");
await File.WriteAllTextAsync(absolute, "secret");
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _service.LoadAsync(absolute));
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _service.RemoveAsync(absolute));
Assert.That(File.Exists(absolute), Is.True);
}
[Test]
public async Task ReadOnlyFileCanBeDeletedAndRepeatedDeleteIsANoOp()
{
var path = await _service.SaveAsync(new byte[] { 1, 2 }, "../file.bin");
var fullPath = Path.Combine(_root, "uploads", path);
File.SetAttributes(fullPath, File.GetAttributes(fullPath) | FileAttributes.ReadOnly);
await _service.RemoveAsync(path);
await _service.RemoveAsync(path);
Assert.That(File.Exists(fullPath), Is.False);
}
[TestCase("")]
[TestCase(" ")]
[TestCase(null)]
public void InvalidPathsAreRejected(string? path)
{
Assert.ThrowsAsync<ArgumentException>(() => _service.LoadAsync(path!));
Assert.ThrowsAsync<ArgumentException>(() => _service.RemoveAsync(path!));
}
[Test]
public async Task ReusingExistingRootIsSafeAndMissingLoadIsReported()
{
_service = new(_root);
Assert.ThrowsAsync<FileNotFoundException>(() => _service.LoadAsync("missing.bin"));
var relative = await _service.SaveAsync(new byte[] { 3, 4 }, "same.bin");
await using var stream = await _service.LoadAsync(relative);
Assert.That(stream.CanRead, Is.True);
Assert.That(stream.Length, Is.EqualTo(2));
}
}
@@ -0,0 +1,137 @@
using AutoFixture;
using Microsoft.AspNetCore.Hosting;
using Moq;
namespace Govor.Application.Tests.Services;
[TestFixture]
public class LocalStorageServiceTests
{
private Fixture _fixture = null!;
private IStorageService _service = null!;
private Mock<IWebHostEnvironment> _webHostEnvironmentMock = null!;
private string _tempDirectory = null!;
[SetUp]
public void SetUp()
{
_fixture = new Fixture();
_webHostEnvironmentMock = new Mock<IWebHostEnvironment>();
_tempDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(_tempDirectory);
_webHostEnvironmentMock.Setup(w => w.ContentRootPath).Returns(_tempDirectory);
_service = new LocalStorageService(_webHostEnvironmentMock.Object.ContentRootPath);
}
[TearDown]
public void TearDown()
{
if (Directory.Exists(_tempDirectory))
{
Directory.Delete(_tempDirectory, true);
}
}
[Test]
public async Task Given_ValidDataAndFileName_When_SaveAsync_Then_FileIsSaved()
{
// Arrange
var data = _fixture.CreateMany<byte>(1000).ToArray();
var fileName = _fixture.Create<string>() + ".txt";
var saveDate = DateTime.UtcNow;
// Act
var url = await _service.SaveAsync(data, fileName);
// Assert
Assert.That(url, Is.Not.Null);
// _tempDirectory/uploads/yyyy/MM/url
var datePath = saveDate.ToString("yyyy/MM");
var expectedFilePath = Path.Combine(_tempDirectory, "uploads", url);
Assert.That(File.Exists(expectedFilePath), Is.True);
}
[Test]
public void Given_EmptyName_When_SaveAsync_Should_Throw_ArgumentException()
{
// Arrange
var data = _fixture.CreateMany<byte>(1000).ToArray();
// Act & Assert
Assert.ThrowsAsync<ArgumentException>(async () => await _service.SaveAsync(data, string.Empty));
}
[Test]
public void Given_EmptyData_When_SaveAsync_Should_Throw_ArgumentException()
{
// Arrange
var name = _fixture.Create<string>();
// Act & Assert
Assert.ThrowsAsync<ArgumentException>(async () => await _service.SaveAsync(default, name));
}
[Test]
public async Task Given_ValidUrl_When_LoadAsync_Then_Returns_FileStream()
{
// Arrange
var date = DateTime.UtcNow.ToString("yyyy/MM");
var corePath = Path.Combine(_tempDirectory, "uploads", date);
Directory.CreateDirectory(corePath);
var fileName = _fixture.Create<string>() + ".txt";
var fileContent = _fixture.Create<string>();
var filePath = Path.Combine(corePath, fileName);
await File.WriteAllTextAsync(filePath, fileContent);
// Act
var url = Path.Combine(date, fileName);
await using var stream = await _service.LoadAsync(url);
// Assert
Assert.That(stream, Is.Not.Null);
Assert.That(stream.Length, Is.GreaterThan(0));
// Дополнительная проверка: содержимое файла
using var reader = new StreamReader(stream);
var content = await reader.ReadToEndAsync();
Assert.That(content, Is.EqualTo(fileContent));
}
[Test]
public void Given_EmptyUrl_When_LoadAsync_Should_Throw_FileNotFoundException()
{
// Act & Assert
Assert.ThrowsAsync<FileNotFoundException>(async () => await _service.LoadAsync(_fixture.Create<string>()+".txt"));
}
[Test]
public async Task Given_ValidUrl_When_DeleteAsync_Then_FileIsDeleted()
{
// Arrange
var date = DateTime.UtcNow.ToString("yyyy/MM");
var corePath = Path.Combine(_tempDirectory, "uploads", date);
Directory.CreateDirectory(corePath);
var fileName = _fixture.Create<string>() + ".txt";
var fileContent = _fixture.Create<string>();
var filePath = Path.Combine(corePath, fileName);
await File.WriteAllTextAsync(filePath, fileContent);
// Act
var url = Path.Combine(date, fileName);
await _service.RemoveAsync(url);
Assert.That(File.Exists(filePath), Is.False);
}
[Test]
public async Task Given_InvalidUrl_When_DeleteAsync_TShould_Not_Throw()
{
// Act & Assert
Assert.DoesNotThrowAsync(async () => await _service.RemoveAsync(_fixture.Create<string>()+".txt"));
}
}
@@ -0,0 +1,105 @@
using Govor.Application.Synching;
namespace Govor.Application.Tests.Services;
[TestFixture]
public class SynchingServiceTests
{
private readonly SynchingService _sut; // System Under Test
public SynchingServiceTests()
{
_sut = new SynchingService();
}
[Test]
public void NormalizeNewlines_ShouldReturnEmptyString_WhenInputIsEmpty()
{
// Act
var result = _sut.NormalizeNewlines(string.Empty);
// Assert
Assert.That(result, Is.EqualTo(string.Empty));
}
[Test]
public void NormalizeNewlines_ShouldReturnNull_WhenInputIsNull()
{
// Arrange
string input = null;
// Act
var result = _sut.NormalizeNewlines(input);
// Assert
Assert.That(result, Is.Null);
}
[Test]
public void NormalizeNewlines_ShouldNotChangeUnixStyleNewlines_WhenInputIsLF()
{
// Arrange
const string input = "Line 1\nLine 2\nLine 3";
// Act
var result = _sut.NormalizeNewlines(input);
// Assert
Assert.That(result, Is.EqualTo(input));
}
[Test]
public void NormalizeNewlines_ShouldConvertWindowsStyleNewlines_WhenInputIsCRLF()
{
// Arrange
const string input = "Line 1\r\nLine 2\r\nLine 3";
const string expected = "Line 1\nLine 2\nLine 3";
// Act
var result = _sut.NormalizeNewlines(input);
// Assert
Assert.That(result, Is.EqualTo(expected));
}
[Test]
public void NormalizeNewlines_ShouldConvertMacStyleNewlines_WhenInputIsCR()
{
// Arrange
const string input = "Line 1\rLine 2\rLine 3";
const string expected = "Line 1\nLine 2\nLine 3";
// Act
var result = _sut.NormalizeNewlines(input);
// Assert
Assert.That(result, Is.EqualTo(expected));
}
[Test]
public void NormalizeNewlines_ShouldHandleMixedNewlines_WhenInputIsMixed()
{
// Arrange
const string input = "Line 1\r\nLine 2\rLine 3\nLine 4";
const string expected = "Line 1\nLine 2\nLine 3\nLine 4";
// Act
var result = _sut.NormalizeNewlines(input);
// Assert
Assert.That(result, Is.EqualTo(expected));
}
[Test]
public void NormalizeNewlines_ShouldHandleTextWithoutNewlines()
{
// Arrange
const string input = "This is a single line of text.";
// Act
var result = _sut.NormalizeNewlines(input);
// Assert
Assert.That(result, Is.EqualTo(input));
}
}
@@ -0,0 +1,43 @@
using Govor.Application.Users.UserOnlineStatus;
namespace Govor.Application.Tests.Users;
[TestFixture]
public class OnlineUserStoreTests
{
[Test]
public void UserRemainsOnlineUntilLastConnectionLeaves()
{
var store = new OnlineUserStore();
var user = Guid.NewGuid();
Assert.That(store.IsOnline(user), Is.False);
Assert.That(store.AddConnection(user, "phone"), Is.True);
Assert.That(store.AddConnection(user, "desktop"), Is.False);
Assert.That(store.AddConnection(user, "phone"), Is.False);
Assert.That(store.GetConnections(user), Is.EquivalentTo(new[] { "phone", "desktop" }));
Assert.That(store.GetAllOnlineUsers(), Is.EqualTo(new[] { user }));
Assert.That(store.RemoveConnection(user, "phone"), Is.False);
Assert.That(store.IsOnline(user), Is.True);
Assert.That(store.RemoveConnection(user, "desktop"), Is.True);
Assert.That(store.IsOnline(user), Is.False);
Assert.That(store.GetAllOnlineUsers(), Is.Empty);
Assert.That(store.GetConnections(user), Is.Empty);
}
[Test]
public void ConnectionSnapshotsAndOtherUsersAreIndependent()
{
var store = new OnlineUserStore();
var alice = Guid.NewGuid();
var bob = Guid.NewGuid();
store.AddConnection(alice, "alice");
var snapshot = store.GetConnections(alice);
store.AddConnection(alice, "second");
store.AddConnection(bob, "bob");
store.RemoveConnection(alice, "alice");
store.RemoveConnection(alice, "second");
Assert.That(snapshot, Is.EqualTo(new[] { "alice" }));
Assert.That(store.IsOnline(bob), Is.True);
Assert.That(store.RemoveConnection(Guid.NewGuid(), "unknown"), Is.False);
}
}
@@ -0,0 +1,62 @@
using AutoFixture;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Microsoft.Extensions.Logging;
using Moq;
namespace Govor.Application.Tests.Services.UserOnlineStatus;
[TestFixture]
[TestOf(typeof(UserNotificationScopeService))]
public class UserNotificationScopeServiceTests
{
private Mock<ILogger<UserNotificationScopeService>> _mockLogger = null!;
private Mock<IFriendshipService> _mockFriendshipService = null!;
private IUserNotificationScopeService _service = null!;
private Fixture _fixture = null!;
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());
_userId = Guid.NewGuid();
_mockLogger = new Mock<ILogger<UserNotificationScopeService>>();
_mockFriendshipService = new Mock<IFriendshipService>();
_service = new UserNotificationScopeService(_mockLogger.Object, _mockFriendshipService.Object);
}
[Test]
public async Task GetNotifiedUsers_ReturnsNotifiedUsers()
{
// Arrange
var random = new Random();
var users = _fixture.CreateMany<User>(random.Next(3, 10)).ToList();
_mockFriendshipService.Setup(f => f.GetFriendsAsync(_userId))
.ReturnsAsync(users);
// Act
var result = await _service.GetNotifiedUsers(_userId);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.EqualTo(users.Count));
Assert.That(result, Is.EquivalentTo(users.Select(u => u.Id)));
}
[Test]
public async Task GetNotifiedUsers_PropagatesFriendshipServiceFailure()
{
// Arrange
_mockFriendshipService.Setup(f => f.GetFriendsAsync(_userId))
.ThrowsAsync(new InvalidOperationException("Database is empty."));
// Act & Assert
var ex = Assert.ThrowsAsync<InvalidOperationException>(async () => await _service.GetNotifiedUsers(_userId));
Assert.That(ex.Message, Is.EqualTo("Database is empty."));
}
}