Add reactions, reliable push & session checks

Implements message reactions and reaction packs (domain models, services, admin HTTP API, media processing via ImageSharp and limits) and adds reliable push delivery (ChatPushNotification, ChatPushDispatcher, ChatPushWorker, improved ChatNotificationService). Enhances message reading (ReadChat API, unread counts, concurrency-safe receipts) and tightens session security (access-token session validation in JWT, hub filter, SessionAuthorization). Improves SignalR behavior (session groups, reaction/channel events, hub/error mappings). Adds EF migrations, many controller fixes (Forbid handling, password API), tests (Govor.Server.Tests), docs, CI and tooling updates (Dockerfile → .NET 10, GH Actions matrix for sqlite/postgres, Govor.Server.slnx, global.json), and small infra changes (AutoMapper bump, NullPushProvider, storage/token handling).
This commit is contained in:
Artemy
2026-10-03 17:42:24 +07:00
parent 4603be9f71
commit 29cc51ee0c
127 changed files with 7290 additions and 2488 deletions
@@ -0,0 +1,21 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
<IsTestProject>true</IsTestProject>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
<PackageReference Include="NUnit" Version="4.4.0-beta.1" />
<PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
<PackageReference Include="Moq" Version="4.20.72" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.10" />
<PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="3.0.3" />
<PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.10" />
<Using Include="NUnit.Framework" />
<ProjectReference Include="../Govor.API/Govor.API.csproj" />
<Reference Include="SmartRes"><HintPath>../libs/SmartRes.dll</HintPath></Reference>
</ItemGroup>
</Project>
+37
View File
@@ -0,0 +1,37 @@
using Govor.API.Filters;
using Govor.Contracts.Responses.SignalR;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Server.Tests;
[TestFixture]
public class HubSessionTests
{
[Test]
public async Task InvalidSessionReturnsAHubResultAndAbortsWithoutRunningMethod()
{
using var db = new TestDatabase();
var caller = new Mock<HubCallerContext>();
var hub = new StubHub();
var invocation = new HubInvocationContext(caller.Object, Mock.Of<IServiceProvider>(), hub,
typeof(StubHub).GetMethod(nameof(StubHub.Echo))!, Array.Empty<object?>());
var filter = new HubExceptionFilter(NullLogger<HubExceptionFilter>.Instance, db.Context);
var invoked = false;
var response = await filter.InvokeMethodAsync(invocation, _ =>
{
invoked = true;
return ValueTask.FromResult<object?>(HubResult<string>.Ok("unexpected"));
});
Assert.That(invoked, Is.False);
Assert.That(response, Is.TypeOf<HubResult<string>>());
Assert.That(((HubResult<string>)response!).Status, Is.EqualTo(HubResultStatus.Unauthorized));
caller.Verify(c => c.Abort(), Times.Once);
}
private sealed class StubHub : Hub
{
public Task<HubResult<string>> Echo() => Task.FromResult(HubResult<string>.Ok("ok"));
}
}
+218
View File
@@ -0,0 +1,218 @@
using Govor.Application.Infrastructure.Common;
using Govor.Application.Medias;
using Govor.Application.Messages;
using Govor.Application.Messages.Parameters;
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.Server.Tests;
[TestFixture]
public class MessageAccessTests
{
private TestDatabase _db = null!;
private MessageReadingService _reader = null!;
private readonly DateTime _now = new(2026, 10, 3, 0, 0, 0, DateTimeKind.Utc);
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
var clock = new Mock<INowDateTimeProvider>();
clock.SetupGet(c => c.Now).Returns(_now);
_reader = new MessageReadingService(_db.Context, NullLogger<MessageReadingService>.Instance, clock.Object);
}
[TearDown]
public void TearDown() => _db.Dispose();
[Test]
public async Task OutsiderCannotLoadSendReadOrDownloadPrivateMessages()
{
// The outsider has a different chat; that must not grant access to Alice–Bob.
_db.Context.PrivateChats.Add(new PrivateChat
{ Id = Guid.NewGuid(), UserAId = _db.Outsider, UserBId = _db.Alice });
var message = _db.AddMessage();
var loader = new MessagesLoader(_db.Context);
var loaded = await loader.LoadMessagesInUserChat(_db.ChatId, _db.Outsider, null);
var read = await _reader.ReadMessageAsync(_db.Outsider, message.Id);
var sender = new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance);
var sent = await sender.SendMessageAsync(new SendMessage("intrusion", null, _db.ChatId,
RecipientType.User, _db.Outsider, _now, []));
Assert.Multiple(() =>
{
Assert.That(loaded.Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That(read.Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That(sent.IsSuccess, Is.False);
});
Assert.That(await _db.Context.MessageViews.CountAsync(), Is.Zero);
Assert.That(await _db.Context.Messages.CountAsync(), Is.EqualTo(1));
}
[Test]
public async Task RepeatedSingleReadReturnsTheSameReceipt()
{
var message = _db.AddMessage();
var first = await _reader.ReadMessageAsync(_db.Bob, message.Id);
var second = await _reader.ReadMessageAsync(_db.Bob, message.Id);
Assert.That(first.IsSuccess && second.IsSuccess, Is.True);
Assert.That(second.Value.MessageViews.Single().Id, Is.EqualTo(first.Value.MessageViews.Single().Id));
Assert.That(second.Value.MessageViews.Single().ViewedAt, Is.EqualTo(_now));
Assert.That(await _db.Context.MessageViews.CountAsync(), Is.EqualTo(1));
}
[Test]
public async Task VisibleMessageSelectionDoesNotReadOffscreenOrOwnMessages()
{
var visible = _db.AddMessage();
_db.AddMessage();
_db.AddMessage(_db.Bob);
var result = await _reader.ReadChatAsync(_db.Bob, _db.ChatId, RecipientType.User, [visible.Id]);
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.Value.ReadCount, Is.EqualTo(1));
Assert.That(result.Value.UnreadCount, Is.EqualTo(1));
Assert.That(await _db.Context.MessageViews.CountAsync(), Is.EqualTo(1));
}
[Test]
public async Task InvalidMixedChatSelectionDoesNotPartiallyWrite()
{
var valid = _db.AddMessage();
var other = _db.AddMessage(chat: Guid.NewGuid());
var result = await _reader.ReadChatAsync(_db.Bob, _db.ChatId, RecipientType.User, [valid.Id, other.Id]);
Assert.That(result.IsFailure, Is.True);
Assert.That(await _db.Context.MessageViews.CountAsync(), Is.Zero);
}
[Test]
public async Task ReadThroughBoundaryHandlesEqualTimestampsAndLeavesNewerUnread()
{
var earlier = _db.AddMessage(sentAt: _now, id: Guid.Parse("00000000-0000-0000-0000-000000000001"));
var boundary = _db.AddMessage(sentAt: _now, id: Guid.Parse("00000000-0000-0000-0000-000000000002"));
_db.AddMessage(sentAt: _now, id: Guid.Parse("00000000-0000-0000-0000-000000000003"));
_db.AddMessage(sentAt: _now.AddSeconds(1));
var result = await _reader.ReadChatAsync(_db.Bob, _db.ChatId, RecipientType.User, upToMessageId: boundary.Id);
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.Value.ReadCount, Is.EqualTo(2));
Assert.That(result.Value.UnreadCount, Is.EqualTo(2));
Assert.That(await _db.Context.MessageViews.AnyAsync(v => v.MessageId == earlier.Id), Is.True);
}
[Test]
public async Task MarkAllReadsMoreThanOneBatchAndSurvivesRepeatedCall()
{
for (var i = 0; i < 205; i++)
_db.AddMessage(sentAt: _now.AddSeconds(i));
_db.AddMessage(_db.Bob, sentAt: _now.AddSeconds(300));
var first = await _reader.ReadChatAsync(_db.Bob, _db.ChatId, RecipientType.User);
var second = await _reader.ReadChatAsync(_db.Bob, _db.ChatId, RecipientType.User);
Assert.That(first.Value.ReadCount, Is.EqualTo(205));
Assert.That(second.Value.ReadCount, Is.Zero);
Assert.That(second.Value.UnreadCount, Is.Zero);
}
[Test]
public async Task GroupReadRequiresMembershipAndExcludesOwnMessages()
{
var group = new ChatGroup { Id = Guid.NewGuid(), Name = "group", Description = "" };
_db.Context.ChatGroups.Add(group);
_db.Context.GroupMemberships.Add(new GroupMembership { Id = Guid.NewGuid(), GroupId = group.Id, UserId = _db.Bob });
_db.Context.SaveChanges();
_db.AddMessage(chat: group.Id, type: RecipientType.Group);
_db.AddMessage(_db.Bob, group.Id, RecipientType.Group);
var denied = await _reader.ReadChatAsync(_db.Outsider, group.Id, RecipientType.Group);
var read = await _reader.ReadChatAsync(_db.Bob, group.Id, RecipientType.Group);
Assert.That(denied.Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That(read.Value.ReadCount, Is.EqualTo(1));
Assert.That(read.Value.UnreadCount, Is.Zero);
}
[Test]
public async Task PrivateAttachmentIsAvailableToBothParticipantsOnly()
{
var message = _db.AddMessage();
var file = new MediaFile { Id = Guid.NewGuid(), UploaderId = _db.Alice,
Url = "test", MineType = "image/png", OwnerType = MediaOwnerType.Message };
_db.Context.MediaFiles.Add(file);
_db.Context.MediaAttachments.Add(new MediaAttachments
{ Id = Guid.NewGuid(), MessageId = message.Id, MediaFileId = file.Id });
_db.Context.SaveChanges();
var access = new AccesserToDownloadMediaService(_db.Context);
Assert.That(await access.HasAccessAsync(file.Id, _db.Alice), Is.True);
Assert.That(await access.HasAccessAsync(file.Id, _db.Bob), Is.True);
Assert.That(await access.HasAccessAsync(file.Id, _db.Outsider), Is.False);
}
[Test]
public async Task HideForMeNeverDeletesForEveryone()
{
var message = _db.AddMessage();
var remover = new MessageRemovingService(_db.Context, NullLogger<MessageRemovingService>.Instance);
var result = await remover.DeleteMessageAsync(new DeleteMessage(_db.Alice, message.Id, false));
Assert.That(result.IsFailure, Is.True);
Assert.That(await _db.Context.Messages.AnyAsync(m => m.Id == message.Id), Is.True);
}
[Test]
public async Task SameTimestampHistoryDoesNotSkipMessagesAroundCursor()
{
var earlier = _db.AddMessage(sentAt: _now, id: Guid.Parse("00000000-0000-0000-0000-000000000001"));
var cursor = _db.AddMessage(sentAt: _now, id: Guid.Parse("00000000-0000-0000-0000-000000000002"));
var later = _db.AddMessage(sentAt: _now, id: Guid.Parse("00000000-0000-0000-0000-000000000003"));
var result = await new MessagesLoader(_db.Context).LoadMessagesInUserChat(_db.ChatId, _db.Bob, cursor.Id);
Assert.That(result.Value.Select(m => m.Id), Is.EqualTo(new[] { earlier.Id, cursor.Id, later.Id }));
}
[Test]
public async Task RecipientCannotEditOrDeleteAnotherAuthorsMessage()
{
var message = _db.AddMessage(sentAt: _now);
var editor = new MessageEditingService(_db.Context, NullLogger<MessageEditingService>.Instance,
Microsoft.Extensions.Options.Options.Create(new MessageEditingOptions()));
var edited = await editor.EditMessageAsync(new EditMessage(_db.Bob, message.Id, "changed", _now));
var remover = new MessageRemovingService(_db.Context, NullLogger<MessageRemovingService>.Instance);
var removed = await remover.DeleteMessageAsync(new DeleteMessage(_db.Bob, message.Id, true));
Assert.That(edited.Exception, Is.TypeOf<UnauthorizedAccessException>());
Assert.That(removed.Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That((await _db.Context.Messages.AsNoTracking().SingleAsync()).EncryptedContent, Is.EqualTo("hello"));
}
[Test]
public async Task BannedGroupMemberCannotLoadSendOrReadMessages()
{
var group = new ChatGroup { Id = Guid.NewGuid(), Name = "group", Description = "" };
_db.Context.ChatGroups.Add(group);
_db.Context.GroupMemberships.Add(new GroupMembership
{ Id = Guid.NewGuid(), GroupId = group.Id, UserId = _db.Bob, IsBanned = true });
_db.Context.SaveChanges();
var loaded = await new MessagesLoader(_db.Context).LoadMessagesInChatGroup(group.Id, _db.Bob, null);
var read = await _reader.ReadChatAsync(_db.Bob, group.Id, RecipientType.Group);
var sent = await new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance)
.SendMessageAsync(new SendMessage("hello", null, group.Id, RecipientType.Group, _db.Bob, _now, []));
Assert.That(loaded.Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That(read.Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That(sent.Exception, Is.TypeOf<UnauthorizedAccessException>());
}
[Test]
public async Task ForeignUploadAndReplyFromAnotherChatCannotBeAttached()
{
var file = new MediaFile { Id = Guid.NewGuid(), UploaderId = _db.Bob,
Url = "test", MineType = "image/png", OwnerType = MediaOwnerType.Message };
_db.Context.MediaFiles.Add(file);
_db.Context.SaveChanges();
var sender = new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance);
var attachment = await sender.SendMessageAsync(new SendMessage("hello", null, _db.ChatId,
RecipientType.User, _db.Alice, _now, new[] { new SendMedia(file.Id, "") }));
var other = _db.AddMessage(chat: Guid.NewGuid());
var reply = await sender.SendMessageAsync(new SendMessage("hello", other.Id, _db.ChatId,
RecipientType.User, _db.Alice, _now, []));
Assert.That(attachment.Exception, Is.TypeOf<UnauthorizedAccessException>());
Assert.That(reply.Exception, Is.TypeOf<ArgumentException>());
Assert.That(await _db.Context.ChatPushNotifications.CountAsync(), Is.Zero);
}
}
+162
View File
@@ -0,0 +1,162 @@
using Govor.API.Hubs;
using Govor.API.Hubs.Infrastructure;
using Govor.Application.PrivateUserChats;
using Govor.Application.Profiles;
using Govor.Application.PushNotifications;
using Govor.Contracts.Responses.SignalR;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Govor.Domain.Models.Users;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using SmartRes;
namespace Govor.Server.Tests;
[TestFixture]
public class NotificationTests
{
private TestDatabase _db = null!;
private Mock<IPushNotificationService> _push = null!;
private Mock<IClientProxy> _proxy = null!;
private ChatNotificationService _notifier = null!;
private readonly List<(string Method, string[] Groups)> _events = [];
private string[] _targetGroups = [];
private Guid _aliceSession;
private Guid _bobSession;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
_events.Clear();
_aliceSession = AddSession(_db.Alice);
_bobSession = AddSession(_db.Bob);
AddSession(_db.Bob, revoked: true);
AddSession(_db.Outsider);
_proxy = new Mock<IClientProxy>();
_proxy.Setup(p => p.SendCoreAsync(It.IsAny<string>(), It.IsAny<object?[]>(), It.IsAny<CancellationToken>()))
.Callback<string, object?[], CancellationToken>((method, _, _) => _events.Add((method, _targetGroups)))
.Returns(Task.CompletedTask);
var clients = new Mock<IHubClients>();
clients.Setup(c => c.Groups(It.IsAny<IReadOnlyList<string>>()))
.Callback<IReadOnlyList<string>>(groups => _targetGroups = groups.ToArray())
.Returns(_proxy.Object);
var hub = new Mock<IHubContext<ChatsHub>>();
hub.SetupGet(h => h.Clients).Returns(clients.Object);
var chats = new Mock<IUserPrivateChatsGetterService>();
chats.Setup(c => c.GetPrivateChatAsync(_db.ChatId))
.ReturnsAsync(Result<PrivateChat, Error>.Success(_db.Context.PrivateChats.Single()));
var profiles = new Mock<IProfileService>();
profiles.Setup(p => p.GetUserProfileAsync(_db.Alice))
.ReturnsAsync(Result<UserProfile, Error>.Success(new UserProfile { Id = _db.Alice, Username = "Alice" }));
_push = new Mock<IPushNotificationService>();
_push.Setup(p => p.SendToUsersAsync(It.IsAny<IEnumerable<Guid>>(), It.IsAny<string>(), It.IsAny<string>(),
It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>?>()))
.ReturnsAsync(Govor.Domain.Common.Result.Success());
_notifier = new ChatNotificationService(hub.Object, _push.Object, chats.Object, profiles.Object,
_db.Context, NullLogger<ChatNotificationService>.Instance);
}
[TearDown]
public void TearDown() => _db.Dispose();
[Test]
public async Task PrivateMessageReachesBothActiveSessionsAndPushGoesOnlyToRecipient()
{
var message = Message();
await _notifier.NotifyMessageSentAsync(message);
await _notifier.DeliverPushAsync(message);
Assert.That(_events.Single(e => e.Method == ChatHubConstants.ReceiveMessage).Groups,
Is.EquivalentTo(new[] { ChatHubConstants.GetSessionGroup(_aliceSession), ChatHubConstants.GetSessionGroup(_bobSession) }));
Assert.That(_events.Single(e => e.Method == ChatHubConstants.MessageSent).Groups,
Is.EqualTo(new[] { ChatHubConstants.GetSessionGroup(_aliceSession) }));
_push.Verify(p => p.SendToUsersAsync(It.Is<IEnumerable<Guid>>(ids => ids.SequenceEqual(new[] { _db.Bob })),
"Alice", "hello", "chat_messages", $"chat_{_db.ChatId}",
It.Is<Dictionary<string, string>?>(data => data != null && data["messageId"] == message.MessageId.ToString())), Times.Once);
}
[Test]
public async Task GroupMessageExcludesBannedMembersFromSignalRAndPush()
{
var group = new ChatGroup { Id = Guid.NewGuid(), Name = "group", Description = "" };
_db.Context.ChatGroups.Add(group);
foreach (var user in new[] { _db.Alice, _db.Bob, _db.Outsider })
_db.Context.GroupMemberships.Add(new GroupMembership
{ Id = Guid.NewGuid(), GroupId = group.Id, UserId = user, IsBanned = user == _db.Outsider });
_db.Context.SaveChanges();
var message = Message();
message.RecipientId = group.Id;
message.RecipientType = RecipientType.Group;
await _notifier.NotifyMessageSentAsync(message);
await _notifier.DeliverPushAsync(message);
Assert.That(_events.Single(e => e.Method == ChatHubConstants.ReceiveMessage).Groups.Length, Is.EqualTo(2));
_push.Verify(p => p.SendToUsersAsync(It.Is<IEnumerable<Guid>>(ids => ids.SequenceEqual(new[] { _db.Bob })),
It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),
It.IsAny<Dictionary<string, string>?>()), Times.Once);
}
[Test]
public async Task SignalRFailureStillAttemptsPushAndProviderFailureDoesNotFailSavedSend()
{
_proxy.Setup(p => p.SendCoreAsync(It.IsAny<string>(), It.IsAny<object?[]>(), It.IsAny<CancellationToken>()))
.ThrowsAsync(new InvalidOperationException("offline"));
_push.Setup(p => p.SendToUsersAsync(It.IsAny<IEnumerable<Guid>>(), It.IsAny<string>(), It.IsAny<string>(),
It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>?>()))
.ThrowsAsync(new InvalidOperationException("provider unavailable"));
await _notifier.NotifyMessageSentAsync(Message());
Assert.That(await _notifier.DeliverPushAsync(Message()), Is.False);
_push.Verify(p => p.SendToUsersAsync(It.IsAny<IEnumerable<Guid>>(), It.IsAny<string>(), It.IsAny<string>(),
It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>?>()), Times.Once);
}
[Test]
public async Task ReadNotificationReachesReaderAndAuthorDevices()
{
await _notifier.NotifyChatReadAsync(new ChatReadResponse { ChatId = _db.ChatId, ReaderId = _db.Bob, RecipientType = RecipientType.User });
Assert.That(_events.Single().Method, Is.EqualTo(ChatHubConstants.ChatRead));
Assert.That(_events.Single().Groups, Is.EquivalentTo(new[]
{ ChatHubConstants.GetSessionGroup(_aliceSession), ChatHubConstants.GetSessionGroup(_bobSession) }));
}
[Test]
public async Task ReactionChangesReachBothParticipantsActiveDevices()
{
await _notifier.NotifyMessageReactionsChangedAsync(new MessageReactionsChangedResponse
{ MessageId = Guid.NewGuid(), RecipientId = _db.ChatId, RecipientType = RecipientType.User, ActorId = _db.Bob });
Assert.That(_events.Single().Method, Is.EqualTo(ChatHubConstants.MessageReactionsChanged));
Assert.That(_events.Single().Groups, Is.EquivalentTo(new[]
{ ChatHubConstants.GetSessionGroup(_aliceSession), ChatHubConstants.GetSessionGroup(_bobSession) }));
}
[Test]
public async Task ChannelPolicyChangesExcludeBannedMembers()
{
var group = new ChatGroup { Id = Guid.NewGuid(), Name = "channel", Description = "", IsChannel = true };
_db.Context.ChatGroups.Add(group);
foreach (var user in new[] { _db.Alice, _db.Bob, _db.Outsider })
_db.Context.GroupMemberships.Add(new GroupMembership
{ Id = Guid.NewGuid(), GroupId = group.Id, UserId = user, IsBanned = user == _db.Outsider });
await _db.Context.SaveChangesAsync();
await _notifier.NotifyChannelReactionPolicyChangedAsync(new ChannelReactionPolicyResponse { GroupId = group.Id });
Assert.That(_events.Single().Method, Is.EqualTo(ChatHubConstants.ChannelReactionPolicyChanged));
Assert.That(_events.Single().Groups, Is.EquivalentTo(new[]
{ ChatHubConstants.GetSessionGroup(_aliceSession), ChatHubConstants.GetSessionGroup(_bobSession) }));
}
private Guid AddSession(Guid userId, bool revoked = false)
{
var session = new UserSession { UserId = userId, RefreshTokenHash = Guid.NewGuid().ToString(), IsRevoked = revoked, ExpiresAt = DateTime.UtcNow.AddDays(1) };
_db.Context.UserSessions.Add(session);
_db.Context.SaveChanges();
return session.Id;
}
private UserMessageResponse Message() => new()
{
MessageId = Guid.NewGuid(), SenderId = _db.Alice, RecipientId = _db.ChatId,
RecipientType = RecipientType.User, EncryptedContent = "hello"
};
}
+122
View File
@@ -0,0 +1,122 @@
using Govor.API.Hubs.Infrastructure;
using Govor.Application.Infrastructure.Common;
using Govor.Application.Messages;
using Govor.Application.Messages.Parameters;
using Govor.Application.Profiles;
using Govor.Application.PushNotifications;
using Govor.Contracts.Responses.SignalR;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Server.Tests;
[TestFixture]
public class PushReliabilityTests
{
private TestDatabase _db = null!;
private Mock<INowDateTimeProvider> _clock = null!;
private PushTokenService _tokens = null!;
private DateTime _now;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
_now = DateTime.UtcNow.AddMinutes(1);
_clock = new Mock<INowDateTimeProvider>();
_clock.SetupGet(c => c.Now).Returns(() => _now);
_tokens = new PushTokenService(_db.Context, _clock.Object, NullLogger<PushTokenService>.Instance);
}
[TearDown]
public void TearDown() => _db.Dispose();
[Test]
public async Task SavedMessageHasDurablePushAndFailureRetriesAfterBackoff()
{
var sender = new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance);
var sent = await sender.SendMessageAsync(new SendMessage("hello", null, _db.ChatId,
Govor.Domain.Models.Messages.RecipientType.User, _db.Alice, _now, []));
Assert.That(sent.IsSuccess, Is.True);
Assert.That(await _db.Context.ChatPushNotifications.CountAsync(), Is.EqualTo(1));
var notifier = new Mock<IChatNotificationService>();
notifier.SetupSequence(n => n.DeliverPushAsync(It.IsAny<UserMessageResponse>())).ReturnsAsync(false).ReturnsAsync(true);
var dispatcher = new ChatPushDispatcher(_db.Context, notifier.Object, _clock.Object);
await dispatcher.DispatchAsync();
var pending = await _db.Context.ChatPushNotifications.AsNoTracking().SingleAsync();
Assert.That(pending.Attempts, Is.EqualTo(1));
Assert.That(pending.NextAttemptAt, Is.GreaterThan(_now));
await dispatcher.DispatchAsync();
notifier.Verify(n => n.DeliverPushAsync(It.IsAny<UserMessageResponse>()), Times.Once);
_now = pending.NextAttemptAt.AddSeconds(1);
// A new scope simulates worker restart, while the queued row remains durable.
using var restarted = _db.CreateContext();
await new ChatPushDispatcher(restarted, notifier.Object, _clock.Object).DispatchAsync();
notifier.Verify(n => n.DeliverPushAsync(It.IsAny<UserMessageResponse>()), Times.Exactly(2));
Assert.That(await _db.Context.ChatPushNotifications.CountAsync(), Is.Zero);
}
[Test]
public async Task ReassignedDeviceTokenCannotNotifyThePreviousAccount()
{
var aliceSession = AddSession(_db.Alice);
var bobSession = AddSession(_db.Bob);
await _tokens.AddOrUpdateTokenAsync(_db.Alice, aliceSession, "device-token", "android");
await _tokens.AddOrUpdateTokenAsync(_db.Bob, bobSession, "other-token", "android");
var result = await _tokens.AddOrUpdateTokenAsync(_db.Bob, bobSession, "device-token", "ios");
Assert.That(result.IsSuccess, Is.True);
Assert.That((await _tokens.GetStringsActiveTokensAsync(_db.Alice)).Value, Is.Empty);
Assert.That((await _tokens.GetStringsActiveTokensAsync(_db.Bob)).Value, Is.EqualTo(new[] { "device-token" }));
Assert.That(await _db.Context.UserPushTokens.CountAsync(), Is.EqualTo(1));
}
[Test]
public async Task InactiveTokenCanBeReactivatedButForeignSessionCannotRegisterIt()
{
var session = AddSession(_db.Bob);
await _tokens.AddOrUpdateTokenAsync(_db.Bob, session, "token", "android");
await _tokens.DeactivateTokenBySessionAsync(session);
_db.Context.ChangeTracker.Clear();
Assert.That((await _tokens.GetStringsActiveTokensAsync(_db.Bob)).Value, Is.Empty);
await _tokens.AddOrUpdateTokenAsync(_db.Bob, session, "token", "android");
Assert.That((await _tokens.GetStringsActiveTokensAsync(_db.Bob)).Value, Has.Count.EqualTo(1));
var foreign = await _tokens.AddOrUpdateTokenAsync(_db.Alice, session, "stolen", "android");
Assert.That(foreign.Error.Type, Is.EqualTo(ErrorType.Forbidden));
}
[Test]
public async Task ExpiredOrRevokedSessionTokensAreExcludedWithoutWaitingForCleanup()
{
var session = AddSession(_db.Bob);
await _tokens.AddOrUpdateTokenAsync(_db.Bob, session, "token", "android");
await _db.Context.UserSessions.Where(s => s.Id == session)
.ExecuteUpdateAsync(s => s.SetProperty(row => row.IsRevoked, true));
Assert.That((await _tokens.GetStringsActiveTokensAsync(_db.Bob)).Value, Is.Empty);
Assert.That((await _tokens.GetUsersStringsActiveTokensAsync(new[] { _db.Bob })).Value, Is.Empty);
Assert.That((await _tokens.GetActiveTokenBySessionAsync(session)).Value, Is.Null);
}
[Test]
public async Task ForeignAttachmentCannotBePublishedAsAnAvatar()
{
var media = new MediaFile { Id = Guid.NewGuid(), UploaderId = _db.Alice,
OwnerType = MediaOwnerType.Message, Url = "test", MineType = "image/png" };
_db.Context.MediaFiles.Add(media);
_db.Context.SaveChanges();
var profiles = new ProfileService(_db.Context, NullLogger<ProfileService>.Instance);
var forbidden = await profiles.SetNewIcon(_db.Bob, media.Id);
Assert.That(forbidden.Error.Type, Is.EqualTo(ErrorType.Forbidden));
}
private Guid AddSession(Guid user)
{
var session = new UserSession { UserId = user, ExpiresAt = _now.AddDays(1), RefreshTokenHash = Guid.NewGuid().ToString() };
_db.Context.UserSessions.Add(session);
_db.Context.SaveChanges();
return session.Id;
}
}
+81
View File
@@ -0,0 +1,81 @@
using Govor.Application.Reactions;
using Govor.Domain.Models.Reactions;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats.Gif;
using SixLabors.ImageSharp.Metadata.Profiles.Exif;
using SixLabors.ImageSharp.PixelFormats;
namespace Govor.Server.Tests;
[TestFixture]
public class ReactionMediaTests
{
private readonly ReactionMediaProcessor _processor = new();
[Test]
public async Task StaticImageIsResizedReencodedAndMetadataIsRemoved()
{
using var source = new Image<Rgba32>(512, 256, Color.Red.ToPixel<Rgba32>());
source.Metadata.ExifProfile = new ExifProfile();
source.Metadata.ExifProfile.SetValue(ExifTag.Artist, "private metadata");
using var input = new MemoryStream();
await source.SaveAsJpegAsync(input);
var result = await _processor.ProcessAsync(input.ToArray());
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.Value.Kind, Is.EqualTo(ReactionKind.Image));
Assert.That(result.Value.MimeType, Is.EqualTo("image/png"));
Assert.That(result.Value.Width, Is.LessThanOrEqualTo(128));
Assert.That(result.Value.Height, Is.LessThanOrEqualTo(128));
Assert.That(result.Value.Data.Length, Is.LessThanOrEqualTo(256 * 1024));
using var decoded = Image.Load(result.Value.Data);
Assert.That(decoded.Metadata.ExifProfile, Is.Null);
}
[Test]
public async Task GifKeepsFramesAndTimingWithinLimits()
{
var input = await GifAsync(2, 25, 256);
var result = await _processor.ProcessAsync(input);
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.Value.Kind, Is.EqualTo(ReactionKind.Gif));
Assert.That(result.Value.DurationMilliseconds, Is.EqualTo(500));
Assert.That(result.Value.Data.Length, Is.LessThanOrEqualTo(512 * 1024));
using var decoded = Image.Load(result.Value.Data);
Assert.That(decoded.Frames.Count, Is.EqualTo(2));
Assert.That(decoded.Width, Is.LessThanOrEqualTo(128));
Assert.That(decoded.Frames.Select(f => f.Metadata.GetGifMetadata().FrameDelay), Is.EqualTo(new[] { 25, 25 }));
}
[Test]
public async Task LongAndExcessiveFrameAnimationsAreRejected()
{
Assert.That((await _processor.ProcessAsync(await GifAsync(2, 300))).IsFailure, Is.True);
Assert.That((await _processor.ProcessAsync(await GifAsync(61, 2))).IsFailure, Is.True);
}
[Test]
public async Task UnsupportedMalformedAndOversizedInputsAreRejected()
{
Assert.That((await _processor.ProcessAsync("<svg xmlns='http://www.w3.org/2000/svg'/>"u8.ToArray())).IsFailure, Is.True);
Assert.That((await _processor.ProcessAsync(new byte[ReactionMediaLimits.MaxUploadBytes + 1])).IsFailure, Is.True);
using var source = new Image<Rgba32>(4096, 1);
using var input = new MemoryStream();
await source.SaveAsPngAsync(input);
Assert.That((await _processor.ProcessAsync(input.ToArray())).IsFailure, Is.True);
}
public static async Task<byte[]> GifAsync(int frames, int delay, int dimension = 16)
{
using var image = new Image<Rgba32>(dimension, dimension, Color.Red.ToPixel<Rgba32>());
image.Frames.RootFrame.Metadata.GetGifMetadata().FrameDelay = delay;
for (var i = 1; i < frames; i++)
{
using var next = new Image<Rgba32>(dimension, dimension, (i % 2 == 0 ? Color.Red : Color.Blue).ToPixel<Rgba32>());
next.Frames.RootFrame.Metadata.GetGifMetadata().FrameDelay = delay;
image.Frames.AddFrame(next.Frames.RootFrame);
}
using var input = new MemoryStream();
await image.SaveAsGifAsync(input);
return input.ToArray();
}
}
+194
View File
@@ -0,0 +1,194 @@
using Govor.Application.Infrastructure.Common;
using Govor.Application.Reactions;
using Govor.Application.Storage;
using Govor.Domain;
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.Server.Tests;
[TestFixture]
public class ReactionTests
{
private TestDatabase _db = null!;
private MessageReactionService _reactions = null!;
private ReactionPackService _packs = null!;
private TestReactionStorage _storage = null!;
private readonly DateTime _now = new(2026, 10, 3, 10, 0, 0, DateTimeKind.Utc);
private Guid First => DefaultReactionPack.Items()[0].Id;
private Guid Second => DefaultReactionPack.Items()[1].Id;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
var clock = new Mock<INowDateTimeProvider>();
clock.SetupGet(c => c.Now).Returns(_now);
_storage = new TestReactionStorage();
_reactions = new MessageReactionService(_db.Context, clock.Object);
_packs = new ReactionPackService(_db.Context, clock.Object, new ReactionMediaProcessor(), _storage,
NullLogger<ReactionPackService>.Instance);
MakeAdmin(_db.Context, _db.Alice);
}
[TearDown]
public void TearDown() => _db.Dispose();
[Test]
public async Task DefaultPackIsAutomaticallyAvailableAndImmutable()
{
var mine = await _packs.ListAsync(_db.Bob, installedOnly: true);
Assert.That(mine.Single().IsDefault, Is.True);
Assert.That(mine.Single().Reactions.Count, Is.EqualTo(12));
Assert.That((await _packs.DisableAsync(_db.Alice, DefaultReactionPack.Id)).Error.Type, Is.EqualTo(ErrorType.Validation));
Assert.That((await _packs.AddEmojiAsync(_db.Alice, DefaultReactionPack.Id, "new", "😎")).IsFailure, Is.True);
Assert.That((await _packs.SubscribeAsync(_db.Bob, DefaultReactionPack.Id, false)).IsFailure, Is.True);
}
[Test]
public async Task PutIsIdempotentAndReplacementKeepsOneOwnReaction()
{
var message = _db.AddMessage();
var first = await _reactions.SetAsync(_db.Bob, message.Id, First);
var repeated = await _reactions.SetAsync(_db.Bob, message.Id, First);
Assert.That(first.Value.Version, Is.EqualTo(1));
Assert.That(repeated.Value.Changed, Is.False);
Assert.That(repeated.Value.Version, Is.EqualTo(1));
Assert.That(repeated.Value.ActorReaction!.ReactedAt, Is.EqualTo(_now));
var replaced = await _reactions.SetAsync(_db.Bob, message.Id, Second);
Assert.That(replaced.Value.Version, Is.EqualTo(2));
Assert.That(replaced.Value.Counts.Single().ReactionId, Is.EqualTo(Second));
Assert.That(await _db.Context.MessageReactions.CountAsync(), Is.EqualTo(1));
}
[Test]
public async Task AggregateCountsAndRemovingOwnReactionDoNotRemoveOtherUsers()
{
var message = _db.AddMessage();
await _reactions.SetAsync(_db.Alice, message.Id, First);
await _reactions.SetAsync(_db.Bob, message.Id, First);
var state = await _reactions.GetAsync(_db.Alice, message.Id);
Assert.That(state.Value.Counts.Single().Count, Is.EqualTo(2));
var removed = await _reactions.SetAsync(_db.Bob, message.Id, null);
Assert.That(removed.Value.ActorReaction, Is.Null);
Assert.That(removed.Value.Counts.Single().Count, Is.EqualTo(1));
Assert.That((await _reactions.SetAsync(_db.Bob, message.Id, null)).Value.Changed, Is.False);
Assert.That((await _db.Context.MessageReactions.SingleAsync()).UserId, Is.EqualTo(_db.Alice));
}
[Test]
public async Task OutsiderCannotReadSetOrDeleteReactions()
{
var message = _db.AddMessage();
await _reactions.SetAsync(_db.Alice, message.Id, First);
foreach (var result in new[]
{
await _reactions.GetAsync(_db.Outsider, message.Id),
await _reactions.SetAsync(_db.Outsider, message.Id, Second),
await _reactions.SetAsync(_db.Outsider, message.Id, null)
}) Assert.That(result.Error.Type, Is.EqualTo(ErrorType.Forbidden));
Assert.That(await _db.Context.MessageReactions.CountAsync(), Is.EqualTo(1));
}
[Test]
public async Task ChannelAdministratorSelectsAllowedReactionsAndPolicyFailureRollsBack()
{
var groupId = Channel();
var message = _db.AddMessage(chat: groupId, type: Govor.Domain.Models.Messages.RecipientType.Group);
var selected = await _reactions.SetPolicyAsync(_db.Alice, groupId, ChannelReactionMode.Selected, new[] { First });
Assert.That(selected.Value.Version, Is.EqualTo(1));
Assert.That((await _reactions.SetAsync(_db.Bob, message.Id, First)).IsSuccess, Is.True);
Assert.That((await _reactions.SetAsync(_db.Bob, message.Id, Second)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
var invalid = await _reactions.SetPolicyAsync(_db.Alice, groupId, ChannelReactionMode.Selected, new[] { Second, Guid.NewGuid() });
Assert.That(invalid.IsFailure, Is.True);
var unchanged = await _reactions.GetPolicyAsync(_db.Bob, groupId);
Assert.That(unchanged.Value.Version, Is.EqualTo(1));
Assert.That(unchanged.Value.ReactionIds, Is.EqualTo(new[] { First }));
await _reactions.SetPolicyAsync(_db.Alice, groupId, ChannelReactionMode.None, Array.Empty<Guid>());
Assert.That((await _reactions.SetAsync(_db.Bob, message.Id, First)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
// Restricting new reactions does not erase history; users can still remove their own.
Assert.That((await _reactions.SetAsync(_db.Bob, message.Id, null)).IsSuccess, Is.True);
}
[Test]
public async Task OrdinaryAndBannedMembersCannotChangeChannelPolicy()
{
var group = Channel();
Assert.That((await _reactions.SetPolicyAsync(_db.Bob, group, ChannelReactionMode.None, Array.Empty<Guid>())).Error.Type,
Is.EqualTo(ErrorType.Forbidden));
await _db.Context.GroupMemberships.Where(m => m.GroupId == group && m.UserId == _db.Alice)
.ExecuteUpdateAsync(s => s.SetProperty(m => m.IsBanned, true));
Assert.That((await _reactions.SetPolicyAsync(_db.Alice, group, ChannelReactionMode.All, Array.Empty<Guid>())).Error.Type,
Is.EqualTo(ErrorType.Forbidden));
var message = _db.AddMessage(chat: group, type: Govor.Domain.Models.Messages.RecipientType.Group);
Assert.That((await _reactions.SetAsync(_db.Alice, message.Id, First)).Error.Type, Is.EqualTo(ErrorType.Forbidden));
}
[Test]
public async Task UsersCanShareInstallAndUninstallAnAdminCreatedPack()
{
Assert.That((await _packs.CreateAsync(_db.Bob, "forbidden", "")).Error.Type, Is.EqualTo(ErrorType.Forbidden));
var pack = (await _packs.CreateAsync(_db.Alice, "Custom", "description")).Value;
var item = (await _packs.AddEmojiAsync(_db.Alice, pack.Id, "cool", "😎")).Value;
Assert.That((await _packs.GetSharedAsync(pack.ShareCode)).Value.Reactions.Single().Id, Is.EqualTo(item.Id));
await _packs.SubscribeAsync(_db.Bob, pack.Id, true);
await _packs.SubscribeAsync(_db.Bob, pack.Id, true);
Assert.That(await _db.Context.UserReactionPacks.CountAsync(), Is.EqualTo(1));
Assert.That((await _packs.ListAsync(_db.Bob, installedOnly: true)).Count, Is.EqualTo(2));
await _packs.SubscribeAsync(_db.Bob, pack.Id, false);
Assert.That((await _packs.ListAsync(_db.Bob, installedOnly: true)).Count, Is.EqualTo(1));
// Installation affects the picker, not who may use a publicly shared reaction.
Assert.That((await _reactions.SetAsync(_db.Bob, _db.AddMessage().Id, item.Id)).IsSuccess, Is.True);
}
[Test]
public async Task DisabledPackBlocksNewReactionsButPreservesHistoryAndDefinition()
{
var pack = (await _packs.CreateAsync(_db.Alice, "Custom", "")).Value;
var item = (await _packs.AddEmojiAsync(_db.Alice, pack.Id, "cool", "😎")).Value;
var message = _db.AddMessage();
await _reactions.SetAsync(_db.Bob, message.Id, item.Id);
await _packs.DisableAsync(_db.Alice, pack.Id);
Assert.That((await _reactions.SetAsync(_db.Alice, message.Id, item.Id)).Error.Type, Is.EqualTo(ErrorType.NotFound));
Assert.That((await _reactions.GetAsync(_db.Bob, message.Id)).Value.Counts.Single().ReactionId, Is.EqualTo(item.Id));
Assert.That((await _packs.GetReactionAsync(item.Id)).IsSuccess, Is.True);
Assert.That((await _packs.GetSharedAsync(pack.ShareCode)).IsFailure, Is.True);
}
public static void MakeAdmin(GovorDbContext context, Guid userId)
{
var invite = new Invitation { Id = Guid.NewGuid(), Code = Guid.NewGuid().ToString("N"), IsAdmin = true,
Description = "admin test", EndDate = DateTime.UtcNow.AddDays(1), MaxParticipants = 10 };
context.Invitations.Add(invite);
context.Users.Single(u => u.Id == userId).InviteId = invite.Id;
context.SaveChanges();
}
private Guid Channel()
{
var group = new ChatGroup { Id = Guid.NewGuid(), Name = "channel", Description = "", IsChannel = true };
_db.Context.ChatGroups.Add(group);
foreach (var user in new[] { _db.Alice, _db.Bob })
_db.Context.GroupMemberships.Add(new GroupMembership { Id = Guid.NewGuid(), GroupId = group.Id, UserId = user });
_db.Context.GroupAdmins.Add(new GroupAdmins { Id = Guid.NewGuid(), GroupId = group.Id, UserId = _db.Alice });
_db.Context.SaveChanges();
return group.Id;
}
}
public class TestReactionStorage : IStorageService
{
public Dictionary<string, byte[]> Files { get; } = new();
public Task<string> SaveAsync(byte[] data, string fileName)
{
var path = Guid.NewGuid().ToString("N") + fileName;
Files.Add(path, data.ToArray());
return Task.FromResult(path);
}
public Task<Stream> LoadAsync(string url) => Task.FromResult<Stream>(new MemoryStream(Files[url], writable: false));
public Task RemoveAsync(string url) { Files.Remove(url); return Task.CompletedTask; }
}
+236
View File
@@ -0,0 +1,236 @@
using System.IdentityModel.Tokens.Jwt;
using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Security.Claims;
using System.Text;
using Govor.API.Hubs.Infrastructure;
using Govor.API.Hubs;
using Govor.Application.Storage;
using Govor.Contracts.Requests;
using Govor.Contracts.Responses;
using Govor.Domain.Models.Reactions;
using Microsoft.AspNetCore.SignalR;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using Govor.Contracts.Responses.SignalR;
using Govor.Domain;
using Govor.Domain.Models.Users;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.DataProtection;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Hosting;
using Microsoft.IdentityModel.Tokens;
using Moq;
namespace Govor.Server.Tests;
[TestFixture]
[NonParallelizable]
public class ReadApiTests
{
private const string Secret = "Govor-server-tests-only-signing-key-at-least-64-characters-long-123456";
private TestDatabase _db = null!;
private TestFactory _factory = null!;
private HttpClient _client = null!;
private Mock<IChatNotificationService> _notifier = null!;
private Guid _session;
[SetUp]
public void SetUp()
{
_db = new TestDatabase();
var session = new UserSession { UserId = _db.Bob, ExpiresAt = DateTime.UtcNow.AddDays(1) };
_db.Context.UserSessions.Add(session);
_db.Context.SaveChanges();
_session = session.Id;
_notifier = new Mock<IChatNotificationService>();
_notifier.Setup(n => n.NotifyChatReadAsync(It.IsAny<ChatReadResponse>())).Returns(Task.CompletedTask);
_notifier.Setup(n => n.NotifyMessageReactionsChangedAsync(It.IsAny<MessageReactionsChangedResponse>())).Returns(Task.CompletedTask);
_notifier.Setup(n => n.NotifyChannelReactionPolicyChangedAsync(It.IsAny<ChannelReactionPolicyResponse>())).Returns(Task.CompletedTask);
_factory = new TestFactory(_db, _notifier.Object);
_client = _factory.CreateClient();
}
[TearDown]
public void TearDown()
{
_client.Dispose();
_factory.Dispose();
_db.Dispose();
}
[Test]
public async Task ReadEndpointPersistsReceiptsNotifiesAndReturnsUnreadCount()
{
var message = _db.AddMessage();
Authorize();
var response = await _client.PostAsJsonAsync($"/api/chats/{_db.ChatId}/read",
new { recipientType = 0, messageIds = new[] { message.Id } });
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var body = await response.Content.ReadFromJsonAsync<ChatReadResponse>();
Assert.That(body!.ReadCount, Is.EqualTo(1));
Assert.That(body.UnreadCount, Is.Zero);
_notifier.Verify(n => n.NotifyChatReadAsync(It.Is<ChatReadResponse>(r => r.ReaderId == _db.Bob && r.ChatId == _db.ChatId)), Times.Once);
var count = await _client.GetAsync($"/api/chats/{_db.ChatId}/unread-count?recipientType=0");
Assert.That(count.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(await count.Content.ReadAsStringAsync(), Does.Contain("\"unreadCount\":0"));
}
[Test]
public async Task AnonymousAndRefreshTokenCannotUseReadApi()
{
var path = $"/api/chats/{_db.ChatId}/unread-count?recipientType=0";
Assert.That((await _client.GetAsync(path)).StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized));
Authorize(tokenType: "refresh");
Assert.That((await _client.GetAsync(path)).StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized));
}
[Test]
public async Task SessionRevocationInvalidatesAnAlreadyIssuedAccessToken()
{
Authorize();
await _db.Context.UserSessions.Where(s => s.Id == _session)
.ExecuteUpdateAsync(setters => setters.SetProperty(s => s.IsRevoked, true));
var response = await _client.GetAsync($"/api/chats/{_db.ChatId}/unread-count?recipientType=0");
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized));
}
[Test]
public async Task ForeignChatIsForbiddenAndInvalidSelectionIsBadRequest()
{
var message = _db.AddMessage();
Authorize();
var foreign = await _client.PostAsJsonAsync($"/api/chats/{Guid.NewGuid()}/read", new { recipientType = 0 });
Assert.That(foreign.StatusCode, Is.EqualTo(HttpStatusCode.Forbidden));
var invalid = await _client.PostAsJsonAsync($"/api/chats/{_db.ChatId}/read",
new { recipientType = 0, messageIds = new[] { message.Id }, upToMessageId = message.Id });
Assert.That(invalid.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
Assert.That(await _db.Context.MessageViews.CountAsync(), Is.Zero);
}
[Test]
public async Task OrdinaryUserCannotReadAdminUserList()
{
Authorize();
var response = await _client.GetAsync("/api/admin/Users/all");
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Forbidden));
}
[Test]
public async Task ReactionHttpApiReturnsVersionedCountsAndNotifiesOnlyOnChange()
{
var message = _db.AddMessage();
Authorize();
var packs = await _client.GetFromJsonAsync<List<ReactionPackResponse>>("/api/reaction-packs/mine");
var reaction = packs!.Single(p => p.IsDefault).Reactions.First().Id;
var path = $"/api/messages/{message.Id}/reactions";
var response = await _client.PutAsJsonAsync(path + "/me", new { reactionId = reaction });
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var state = await response.Content.ReadFromJsonAsync<MessageReactionsChangedResponse>();
Assert.That(state!.Version, Is.EqualTo(1));
Assert.That(state.ActorReaction!.ReactionId, Is.EqualTo(reaction));
Assert.That(state.Counts.Single().Count, Is.EqualTo(1));
Assert.That((await _client.PutAsJsonAsync(path + "/me", new { reactionId = reaction })).StatusCode, Is.EqualTo(HttpStatusCode.OK));
_notifier.Verify(n => n.NotifyMessageReactionsChangedAsync(It.IsAny<MessageReactionsChangedResponse>()), Times.Once);
Assert.That((await _client.PutAsJsonAsync(path + "/me", new { reactionId = Guid.Empty })).StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
var removed = await _client.DeleteAsync(path + "/me");
Assert.That(removed.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var empty = await _client.GetFromJsonAsync<MessageReactionsChangedResponse>(path);
Assert.That(empty!.Version, Is.EqualTo(2));
Assert.That(empty.Counts, Is.Empty);
}
[Test]
public async Task AdminPackUploadUsesRealContentAndCanBeSharedAndDownloaded()
{
Authorize();
Assert.That((await _client.PostAsJsonAsync("/api/admin/reaction-packs", new { name = "Custom" })).StatusCode,
Is.EqualTo(HttpStatusCode.Forbidden));
Authorize(role: "Admin");
Assert.That((await _client.PostAsJsonAsync("/api/admin/reaction-packs", new { name = "Custom" })).StatusCode,
Is.EqualTo(HttpStatusCode.Forbidden));
ReactionTests.MakeAdmin(_db.Context, _db.Bob);
var created = await _client.PostAsJsonAsync("/api/admin/reaction-packs", new { name = "Custom", description = "Shared" });
Assert.That(created.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var pack = (await created.Content.ReadFromJsonAsync<ReactionPackResponse>())!;
using var image = new Image<Rgba32>(256, 256);
using var bytes = new MemoryStream();
await image.SaveAsPngAsync(bytes);
using var multipart = new MultipartFormDataContent();
multipart.Add(new StringContent("Picture"), "name");
var upload = new ByteArrayContent(bytes.ToArray());
upload.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
multipart.Add(upload, "file", "incorrect.txt");
var response = await _client.PostAsync($"/api/admin/reaction-packs/{pack.Id}/reactions/media", multipart);
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var item = (await response.Content.ReadFromJsonAsync<ReactionItemResponse>())!;
Assert.That(item.Kind, Is.EqualTo(ReactionKind.Image));
Assert.That(item.Width, Is.EqualTo(128));
Authorize();
var shared = await _client.GetFromJsonAsync<ReactionPackResponse>(pack.SharePath);
Assert.That(shared!.Reactions.Single().Id, Is.EqualTo(item.Id));
Assert.That((await _client.PutAsync($"/api/reaction-packs/{pack.Id}/subscription", null)).StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
var downloaded = await _client.GetAsync(item.MediaUrl);
Assert.That(downloaded.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(downloaded.Content.Headers.ContentType!.MediaType, Is.EqualTo("image/png"));
using var decoded = Image.Load(await downloaded.Content.ReadAsByteArrayAsync());
Assert.That(decoded.Width, Is.EqualTo(128));
}
[Test]
public async Task SignalRReactionMethodsUseTheSameStateAndAccessChecks()
{
var message = _db.AddMessage();
using var scope = _factory.Services.CreateScope();
var hub = ActivatorUtilities.CreateInstance<ChatsHub>(scope.ServiceProvider);
var caller = new Mock<HubCallerContext>();
caller.SetupGet(c => c.User).Returns(new ClaimsPrincipal(new ClaimsIdentity(new[]
{ new Claim("userId", _db.Bob.ToString()), new Claim("sid", _session.ToString()) }, "test")));
hub.Context = caller.Object;
var reaction = DefaultReactionPack.Items().First().Id;
var result = await hub.React(message.Id, new SetReactionRequest { ReactionId = reaction });
Assert.That(result.Status, Is.EqualTo(HubResultStatus.Success));
Assert.That(result.Result!.Counts.Single().Count, Is.EqualTo(1));
Assert.That((await hub.RemoveReaction(message.Id)).Status, Is.EqualTo(HubResultStatus.Success));
Assert.That((await hub.React(Guid.NewGuid(), new SetReactionRequest { ReactionId = reaction })).Status, Is.EqualTo(HubResultStatus.NotFound));
}
private void Authorize(string tokenType = "access", string role = "User")
{
var token = new JwtSecurityToken(claims: new[]
{
new Claim("userId", _db.Bob.ToString()), new Claim("sid", _session.ToString()),
new Claim("tokenType", tokenType), new Claim(ClaimTypes.Role, role)
}, expires: DateTime.UtcNow.AddMinutes(10),
signingCredentials: new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Secret)), SecurityAlgorithms.HmacSha256));
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", new JwtSecurityTokenHandler().WriteToken(token));
}
private sealed class TestFactory(TestDatabase db, IChatNotificationService notifier) : WebApplicationFactory<Program>
{
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.UseEnvironment("Development");
builder.UseSetting("Firebase:Enabled", "false");
builder.UseSetting("JwtAccessOption:SecretKey", Secret);
builder.ConfigureServices(services =>
{
services.AddDataProtection().UseEphemeralDataProtectionProvider();
var worker = services.Single(d => d.ServiceType == typeof(IHostedService) && d.ImplementationType == typeof(ChatPushWorker));
services.Remove(worker);
services.RemoveAll<DbContextOptions<GovorDbContext>>();
services.RemoveAll<IDbContextOptionsConfiguration<GovorDbContext>>();
services.AddDbContext<GovorDbContext>(db.ConfigureOptions);
services.RemoveAll<IChatNotificationService>();
services.AddSingleton(notifier);
services.RemoveAll<IStorageService>();
services.AddSingleton<IStorageService>(new TestReactionStorage());
});
}
}
}
@@ -0,0 +1,84 @@
using System.Data.Common;
using Govor.Application.Infrastructure.Common;
using Govor.Application.Messages;
using Govor.Domain;
using Govor.Domain.Models.Messages;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Diagnostics;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
namespace Govor.Server.Tests;
[TestFixture]
public class ReadConcurrencyTests
{
[Test]
public async Task AnotherDeviceCanInsertTheReceiptBetweenSelectionAndWrite()
{
using var db = new TestDatabase();
var message = db.AddMessage();
var clock = new Mock<INowDateTimeProvider>();
clock.SetupGet(c => c.Now).Returns(DateTime.UtcNow);
using var other = db.CreateContext();
var competingReader = new MessageReadingService(other, NullLogger<MessageReadingService>.Instance, clock.Object);
var interceptor = new BeforeReceiptInsert(async () =>
{
var result = await competingReader.ReadMessageAsync(db.Bob, message.Id);
Assert.That(result.IsSuccess, Is.True);
});
using var first = db.CreateContext(interceptor);
var reader = new MessageReadingService(first, NullLogger<MessageReadingService>.Instance, clock.Object);
var read = await reader.ReadChatAsync(db.Bob, db.ChatId, RecipientType.User, new[] { message.Id });
Assert.That(read.IsSuccess, Is.True);
Assert.That(read.Value.ReadCount, Is.Zero);
Assert.That(await db.Context.MessageViews.CountAsync(), Is.EqualTo(1));
}
[Test]
public async Task MessageRemovedBetweenSelectionAndWriteDoesNotCreateOrphanReceipt()
{
using var db = new TestDatabase();
var message = db.AddMessage();
var clock = new Mock<INowDateTimeProvider>();
clock.SetupGet(c => c.Now).Returns(DateTime.UtcNow);
using var other = db.CreateContext();
var interceptor = new BeforeReceiptInsert(async () =>
await other.Messages.Where(m => m.Id == message.Id).ExecuteDeleteAsync());
using var first = db.CreateContext(interceptor);
var reader = new MessageReadingService(first, NullLogger<MessageReadingService>.Instance, clock.Object);
var read = await reader.ReadChatAsync(db.Bob, db.ChatId, RecipientType.User, new[] { message.Id });
Assert.That(read.IsSuccess, Is.True);
Assert.That(read.Value.ReadCount, Is.Zero);
Assert.That(await db.Context.MessageViews.CountAsync(), Is.Zero);
}
[Test]
public void ReadBoundaryQueryTranslatesForPostgreSql()
{
using var db = new GovorDbContext(new DbContextOptionsBuilder<GovorDbContext>()
.UseNpgsql("Host=localhost;Database=translation_tests;Username=tests").Options);
var boundary = Guid.NewGuid();
var sentAt = DateTime.UtcNow;
var sql = db.Messages.Where(m => m.SentAt < sentAt ||
(m.SentAt == sentAt && m.Id.CompareTo(boundary) <= 0))
.OrderBy(m => m.SentAt).ThenBy(m => m.Id).ToQueryString();
Assert.That(sql, Does.Contain("ORDER BY"));
}
// Deterministically interleave a competing device/deletion after SELECT, before INSERT.
private sealed class BeforeReceiptInsert(Func<Task> callback) : DbCommandInterceptor
{
private bool _invoked;
public override async ValueTask<InterceptionResult<int>> NonQueryExecutingAsync(DbCommand command,
CommandEventData eventData, InterceptionResult<int> result, CancellationToken cancellationToken = default)
{
if (!_invoked && command.CommandText.StartsWith("INSERT INTO \"MessageViews\"", StringComparison.Ordinal))
{
_invoked = true;
await callback();
}
return result;
}
}
}
+106
View File
@@ -0,0 +1,106 @@
using Govor.Domain;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Govor.Domain.Models.Users;
using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;
using System.Data.Common;
using Npgsql;
using Microsoft.EntityFrameworkCore.Diagnostics;
namespace Govor.Server.Tests;
public sealed class TestDatabase : IDisposable
{
public DbConnection Connection { get; }
private readonly string? _schema;
public GovorDbContext Context { get; }
public Guid Alice { get; } = Guid.NewGuid();
public Guid Bob { get; } = Guid.NewGuid();
public Guid Outsider { get; } = Guid.NewGuid();
public Guid ChatId { get; } = Guid.NewGuid();
public TestDatabase()
{
var postgres = Environment.GetEnvironmentVariable("TEST_POSTGRES_CONNECTION");
if (string.IsNullOrWhiteSpace(postgres))
Connection = new SqliteConnection("Data Source=:memory:");
else
{
var settings = new NpgsqlConnectionStringBuilder(postgres);
if (settings.Database?.EndsWith("_tests", StringComparison.Ordinal) != true)
throw new InvalidOperationException("PostgreSQL tests require a dedicated database ending in _tests.");
_schema = "test_" + Guid.NewGuid().ToString("N");
settings.SearchPath = _schema;
Connection = new NpgsqlConnection(settings.ConnectionString);
}
Connection.Open();
if (_schema is not null)
{
using var command = Connection.CreateCommand();
command.CommandText = $"CREATE SCHEMA {_schema}";
command.ExecuteNonQuery();
}
Context = CreateContext();
if (_schema is null)
Context.Database.EnsureCreated();
else
Context.Database.Migrate();
var invite = new Invitation
{
Id = Guid.NewGuid(), Code = "test", Description = "test",
EndDate = DateTime.UtcNow.AddDays(1), MaxParticipants = 100
};
Context.Invitations.Add(invite);
foreach (var id in new[] { Alice, Bob, Outsider })
Context.Users.Add(new User
{
Id = id, Username = id.ToString(), PasswordHash = "test", Description = "",
InviteId = invite.Id, WasOnline = DateTime.UtcNow
});
Context.PrivateChats.Add(new PrivateChat { Id = ChatId, UserAId = Alice, UserBId = Bob });
Context.SaveChanges();
}
public void ConfigureOptions(DbContextOptionsBuilder options)
{
if (_schema is null)
options.UseSqlite(Connection);
else
options.UseNpgsql(Connection);
}
public GovorDbContext CreateContext(params IInterceptor[] interceptors)
{
var options = new DbContextOptionsBuilder<GovorDbContext>();
ConfigureOptions(options);
options.AddInterceptors(interceptors);
return new GovorDbContext(options.Options);
}
public Message AddMessage(Guid? sender = null, Guid? chat = null,
RecipientType type = RecipientType.User, DateTime? sentAt = null, Guid? id = null)
{
var message = new Message
{
Id = id ?? Guid.NewGuid(), SenderId = sender ?? Alice,
RecipientId = chat ?? ChatId, RecipientType = type,
SentAt = sentAt ?? DateTime.UtcNow, EncryptedContent = "hello"
};
Context.Messages.Add(message);
Context.SaveChanges();
return message;
}
public void Dispose()
{
Context.Dispose();
if (_schema is not null)
{
using var command = Connection.CreateCommand();
command.CommandText = $"DROP SCHEMA {_schema} CASCADE";
command.ExecuteNonQuery();
}
Connection.Dispose();
}
}