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,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);
}
}