test: cover core bot and web scenarios

2026-04-23 21:08:41 +03:00
parent 93e7c1ac66
commit bb8cbb7a40
17 changed files with 716 additions and 234 deletions
@@ -0,0 +1,50 @@
+using GmRelay.Bot.Features.Confirmation.HandleRsvp;
+using GmRelay.Shared.Domain;
+
+namespace GmRelay.Bot.Tests.Features.Confirmation.HandleRsvp;
+
+public sealed class RsvpFlowRulesTests
+{
+    [Fact]
+    public void Evaluate_ShouldRevertAndAlert_WhenConfirmedSessionGetsDecline()
+    {
+        var decision = RsvpFlowRules.Evaluate(
+            RsvpStatus.Declined,
+            SessionStatus.Confirmed,
+            totalParticipants: 3,
+            confirmedParticipants: 2);
+
+        Assert.True(decision.ShouldAlertGm);
+        Assert.True(decision.ShouldRevertSessionToConfirmationSent);
+        Assert.False(decision.ShouldMarkSessionConfirmed);
+        Assert.Equal("Вы отказались от участия.", decision.CallbackText);
+    }
+
+    [Fact]
+    public void Evaluate_ShouldMarkConfirmed_WhenLastParticipantConfirms()
+    {
+        var decision = RsvpFlowRules.Evaluate(
+            RsvpStatus.Confirmed,
+            SessionStatus.ConfirmationSent,
+            totalParticipants: 3,
+            confirmedParticipants: 3);
+
+        Assert.True(decision.ShouldMarkSessionConfirmed);
+        Assert.True(decision.ShouldNotifyGroup);
+        Assert.True(decision.ShouldNotifyGm);
+    }
+
+    [Fact]
+    public void Evaluate_ShouldKeepWaiting_WhenNotEveryoneConfirmed()
+    {
+        var decision = RsvpFlowRules.Evaluate(
+            RsvpStatus.Confirmed,
+            SessionStatus.ConfirmationSent,
+            totalParticipants: 4,
+            confirmedParticipants: 2);
+
+        Assert.False(decision.ShouldMarkSessionConfirmed);
+        Assert.False(decision.ShouldNotifyGroup);
+        Assert.False(decision.ShouldNotifyGm);
+    }
+}
@@ -0,0 +1,68 @@
+using GmRelay.Bot.Features.Sessions.CreateSession;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.CreateSession;
+
+public sealed class NewSessionCommandParserTests
+{
+    [Fact]
+    public void Parse_ShouldExtractTitleLinkAndUpcomingTimes()
+    {
+        var nowUtc = new DateTimeOffset(2026, 4, 23, 12, 0, 0, TimeSpan.Zero);
+        var text = """
+            /newsession
+            Название: Curse of Strahd
+            Время: 24.04.2026 19:30
+            Время: 01.05.2026 20:00
+            Ссылка: https://example.test/room
+            """;
+
+        var result = NewSessionCommandParser.Parse(text, nowUtc);
+
+        Assert.True(result.IsValid);
+        Assert.Equal("Curse of Strahd", result.Title);
+        Assert.Equal("https://example.test/room", result.Link);
+        Assert.Equal(
+            [
+                new DateTimeOffset(2026, 4, 24, 16, 30, 0, TimeSpan.Zero),
+                new DateTimeOffset(2026, 5, 1, 17, 0, 0, TimeSpan.Zero)
+            ],
+            result.ScheduledTimes);
+        Assert.Empty(result.PastTimeInputs);
+        Assert.Empty(result.InvalidTimeInputs);
+    }
+
+    [Fact]
+    public void Parse_ShouldCollectPastAndInvalidTimes()
+    {
+        var nowUtc = new DateTimeOffset(2026, 4, 23, 12, 0, 0, TimeSpan.Zero);
+        var text = """
+            Название: Delta Green
+            Время: 20.04.2026 19:30
+            Время: 31.04.2026 19:30
+            Время: 25.04.2026 18:00
+            Ссылка: https://example.test/dg
+            """;
+
+        var result = NewSessionCommandParser.Parse(text, nowUtc);
+
+        Assert.True(result.IsValid);
+        Assert.Single(result.ScheduledTimes);
+        Assert.Equal(["20.04.2026 19:30"], result.PastTimeInputs);
+        Assert.Equal(["31.04.2026 19:30"], result.InvalidTimeInputs);
+    }
+
+    [Fact]
+    public void Parse_ShouldBeInvalid_WhenRequiredFieldsMissing()
+    {
+        var text = """
+            /newsession
+            Название: Blades in the Dark
+            Время: 25.04.2026 19:30
+            """;
+
+        var result = NewSessionCommandParser.Parse(text, DateTimeOffset.UtcNow);
+
+        Assert.False(result.IsValid);
+        Assert.Null(result.Link);
+    }
+}
@@ -0,0 +1,32 @@
+using GmRelay.Bot.Features.Sessions.RescheduleSession;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.RescheduleSession;
+
+public sealed class HandleRescheduleTimeInputHandlerTests
+{
+    [Fact]
+    public void BuildVotingMessage_ShouldShowApprovedAndPendingParticipants()
+    {
+        var approvedId = Guid.NewGuid();
+        var pendingId = Guid.NewGuid();
+        var currentTime = new DateTime(2026, 4, 25, 16, 30, 0, DateTimeKind.Utc);
+        var newTime = new DateTimeOffset(2026, 4, 26, 17, 0, 0, TimeSpan.Zero);
+        var participants = new List<VoteParticipantDto>
+        {
+            new(approvedId, "Alice", "alice"),
+            new(pendingId, "Bob", null)
+        };
+
+        var text = HandleRescheduleTimeInputHandler.BuildVotingMessage(
+            "Shadowrun",
+            currentTime,
+            newTime,
+            participants,
+            [approvedId]);
+
+        Assert.Contains("Shadowrun", text);
+        Assert.Contains("✅ @alice", text);
+        Assert.Contains("⏳ Bob", text);
+        Assert.Contains("Голоса: 1/2 ✅", text);
+    }
+}
@@ -0,0 +1,36 @@
+using GmRelay.Bot.Features.Sessions.RescheduleSession;
+
+namespace GmRelay.Bot.Tests.Features.Sessions.RescheduleSession;
+
+public sealed class RescheduleVoteRulesTests
+{
+    [Fact]
+    public void Evaluate_ShouldReject_WhenParticipantVotesNo()
+    {
+        var decision = RescheduleVoteRules.Evaluate("no", totalParticipants: 4, approvedParticipants: 3);
+
+        Assert.Equal(RescheduleVoteOutcome.Rejected, decision.Outcome);
+        Assert.False(decision.ShouldRescheduleSession);
+        Assert.Equal("Вы проголосовали против переноса.", decision.CallbackText);
+    }
+
+    [Fact]
+    public void Evaluate_ShouldApprove_WhenEveryoneVotedYes()
+    {
+        var decision = RescheduleVoteRules.Evaluate("yes", totalParticipants: 3, approvedParticipants: 3);
+
+        Assert.Equal(RescheduleVoteOutcome.Approved, decision.Outcome);
+        Assert.True(decision.ShouldRescheduleSession);
+        Assert.True(decision.ShouldResetParticipantRsvps);
+    }
+
+    [Fact]
+    public void Evaluate_ShouldStayPending_WhileVotesOutstanding()
+    {
+        var decision = RescheduleVoteRules.Evaluate("yes", totalParticipants: 5, approvedParticipants: 2);
+
+        Assert.Equal(RescheduleVoteOutcome.Pending, decision.Outcome);
+        Assert.False(decision.ShouldRescheduleSession);
+        Assert.False(decision.ShouldResetParticipantRsvps);
+    }
+}
@@ -0,0 +1,47 @@
+using GmRelay.Shared.Domain;
+using GmRelay.Shared.Rendering;
+
+namespace GmRelay.Bot.Tests.Rendering;
+
+public sealed class SessionBatchRendererTests
+{
+    [Fact]
+    public void Render_ShouldOrderSessionsAndSkipButtonsForClosedStatuses()
+    {
+        var firstSessionId = Guid.NewGuid();
+        var secondSessionId = Guid.NewGuid();
+        var cancelledSessionId = Guid.NewGuid();
+
+        var sessions = new[]
+        {
+            new SessionBatchDto(secondSessionId, new DateTime(2026, 4, 27, 18, 0, 0, DateTimeKind.Utc), "Planned"),
+            new SessionBatchDto(cancelledSessionId, new DateTime(2026, 4, 28, 18, 0, 0, DateTimeKind.Utc), "Cancelled"),
+            new SessionBatchDto(firstSessionId, new DateTime(2026, 4, 26, 18, 0, 0, DateTimeKind.Utc), "RecruitmentClosed")
+        };
+        var participants = new[]
+        {
+            new ParticipantBatchDto(secondSessionId, "Alice", "alice"),
+            new ParticipantBatchDto(cancelledSessionId, "Bob", null)
+        };
+
+        var result = SessionBatchRenderer.Render("Campaign", sessions, participants);
+        var text = result.Text;
+        var buttons = result.Markup.InlineKeyboard.SelectMany(row => row).ToList();
+
+        var firstIndex = text.IndexOf(sessions[2].ScheduledAt.FormatMoscow(), StringComparison.Ordinal);
+        var secondIndex = text.IndexOf(sessions[0].ScheduledAt.FormatMoscow(), StringComparison.Ordinal);
+        var thirdIndex = text.IndexOf(sessions[1].ScheduledAt.FormatMoscow(), StringComparison.Ordinal);
+
+        Assert.Contains("Campaign", text);
+        Assert.True(firstIndex < secondIndex);
+        Assert.True(secondIndex < thirdIndex);
+        Assert.Contains("@alice", text);
+        Assert.Contains("Bob", text);
+        Assert.Single(result.Markup.InlineKeyboard);
+        Assert.Collection(
+            buttons.Select(button => button.CallbackData),
+            callbackData => Assert.Equal($"join_session:{secondSessionId}", callbackData),
+            callbackData => Assert.Equal($"cancel_session:{secondSessionId}", callbackData),
+            callbackData => Assert.Equal($"reschedule_session:{secondSessionId}", callbackData));
+    }
+}
@@ -66,6 +66,27 @@ public sealed class AuthorizedSessionServiceTests
        Assert.Equal(sessionId, session.Id);
    }

+    [Fact]
+    public async Task GetSessionForGmAsync_ReturnsNull_WhenSessionBelongsToAnotherGm()
+    {
+        var groupId = Guid.NewGuid();
+        var sessionId = Guid.NewGuid();
+        var store = new FakeSessionStore(
+            groups:
+            [
+                new(groupId, 42, "Alpha", 2002L)
+            ],
+            sessions:
+            [
+                new(sessionId, groupId, "Session A", DateTime.UtcNow, "Planned", "https://example.test/a", Guid.NewGuid(), 10, 42)
+            ]);
+        var service = new AuthorizedSessionService(store);
+
+        var session = await service.GetSessionForGmAsync(sessionId, 1001L);
+
+        Assert.Null(session);
+    }
+
    [Fact]
    public async Task UpdateSessionForGmAsync_Throws_WhenSessionBelongsToAnotherGm()
    {
@@ -0,0 +1,109 @@
+using System.Security.Cryptography;
+using System.Text;
+using GmRelay.Web.Services;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Primitives;
+
+namespace GmRelay.Bot.Tests.Web;
+
+public sealed class TelegramAuthServiceTests
+{
+    [Fact]
+    public void Verify_ShouldAcceptValidTelegramPayload()
+    {
+        const string botToken = "test-bot-token";
+        var authDate = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
+        var query = CreateQueryCollection(
+            botToken,
+            new Dictionary<string, string>
+            {
+                ["auth_date"] = authDate,
+                ["first_name"] = "Ada",
+                ["id"] = "424242",
+                ["last_name"] = "Lovelace",
+                ["username"] = "ada"
+            });
+        var service = new TelegramAuthService(CreateConfiguration(botToken));
+
+        var verified = service.Verify(query, out var telegramId, out var name);
+
+        Assert.True(verified);
+        Assert.Equal(424242L, telegramId);
+        Assert.Equal("Ada Lovelace", name);
+    }
+
+    [Fact]
+    public void Verify_ShouldRejectTamperedHash()
+    {
+        const string botToken = "test-bot-token";
+        var values = new Dictionary<string, string>
+        {
+            ["auth_date"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString(),
+            ["first_name"] = "Ada",
+            ["id"] = "424242"
+        };
+        var query = CreateQueryCollection(botToken, values);
+        var invalidQuery = new QueryCollection(new Dictionary<string, StringValues>(query.ToDictionary(
+            pair => pair.Key,
+            pair => pair.Value))
+        {
+            ["hash"] = "00"
+        });
+        var service = new TelegramAuthService(CreateConfiguration(botToken));
+
+        var verified = service.Verify(invalidQuery, out _, out _);
+
+        Assert.False(verified);
+    }
+
+    [Fact]
+    public void Verify_ShouldRejectExpiredPayload()
+    {
+        const string botToken = "test-bot-token";
+        var expiredAuthDate = DateTimeOffset.UtcNow.AddDays(-2).ToUnixTimeSeconds().ToString();
+        var query = CreateQueryCollection(
+            botToken,
+            new Dictionary<string, string>
+            {
+                ["auth_date"] = expiredAuthDate,
+                ["first_name"] = "Ada",
+                ["id"] = "424242"
+            });
+        var service = new TelegramAuthService(CreateConfiguration(botToken));
+
+        var verified = service.Verify(query, out _, out _);
+
+        Assert.False(verified);
+    }
+
+    private static IConfiguration CreateConfiguration(string botToken) =>
+        new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                ["Telegram:BotToken"] = botToken
+            })
+            .Build();
+
+    private static QueryCollection CreateQueryCollection(string botToken, Dictionary<string, string> values)
+    {
+        var hash = ComputeTelegramHash(botToken, values);
+        var queryValues = values.ToDictionary(
+            pair => pair.Key,
+            pair => new StringValues(pair.Value));
+        queryValues["hash"] = new StringValues(hash);
+        return new QueryCollection(queryValues);
+    }
+
+    private static string ComputeTelegramHash(string botToken, IReadOnlyDictionary<string, string> values)
+    {
+        var dataCheckString = string.Join(
+            "\n",
+            values
+                .OrderBy(pair => pair.Key, StringComparer.Ordinal)
+                .Select(pair => $"{pair.Key}={pair.Value}"));
+        var secretKey = SHA256.HashData(Encoding.UTF8.GetBytes(botToken));
+        var hashBytes = HMACSHA256.HashData(secretKey, Encoding.UTF8.GetBytes(dataCheckString));
+        return Convert.ToHexString(hashBytes).ToLowerInvariant();
+    }
+}