Radicade Public Code

2026-10-25 23:18:56 -07:00 · 2026-10-16 23:33:13 -07:00
commit 55175acdf6
832 changed files with 363261 additions and 0 deletions
@@ -0,0 +1,977 @@
+using System.Reflection;
+using System.Security.Claims;
+using System.Text;
+using System.Text.Json;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging.Abstractions;
+using RadicadeServer.API.Moderation;
+using RadicadeServer.API.Notifications;
+using RadicadeServer.DB;
+using RadicadeServer.RecNet.Accounts;
+using RadicadeServer.RecNet.Auth;
+using RadicadeServer.RecNet.Enums;
+using RadicadeServer.RecNet.Enums.Messages;
+using RadicadeServer.RecNet.Enums.Moderation;
+using RadicadeServer.RecNet.Enums.Rooms;
+using RadicadeServer.RecNet.Messages;
+using RadicadeServer.RecNet.Moderation;
+using RadicadeServer.RecNet.Notifications;
+using RadicadeServer.RecNet.Rooms;
+using RadicadeServer.Utils;
+using Xunit;
+
+namespace RadicadeServer.Tests;
+
+/// <summary>
+/// The moderator warning endpoints (<c>POST api/playerwarnings</c> and
+/// <c>POST api/playerwarnings/acknowledge</c>).
+///
+/// The 2023 client has the whole feature - the "Warn Player" action, a warn screen with an
+/// "Acknowledge warning" button, and both route literals in its RecNet layer - but this server
+/// mapped neither route, so every warn 404'd. A 404 there is silent: nothing logs, the button
+/// just does nothing, which is why it went unnoticed.
+///
+/// The route assertions are the point of this file, for the same reason they are in
+/// RoleLookupTests: a correct handler behind a missing prefix is the failure mode this project
+/// keeps hitting. These two templates are absolute (they start with "/"), so ASP.NET ignores the
+/// controller's own <c>api/PlayerReporting/</c> prefix - the client's literal is the whole path.
+/// </summary>
+[Collection(DbFactoryCollection.Name)]
+public class PlayerWarningTests
+{
+    // Mirrors the server's MVC JSON options, including PropertyNameCaseInsensitive - which is
+    // what makes System.Text.Json reject a type whose members differ only in case. Without it a
+    // case-colliding response DTO serializes fine in a test and 500s in production.
+    private static readonly JsonSerializerOptions ServerJson = new()
+    {
+        PropertyNamingPolicy = null,
+        PropertyNameCaseInsensitive = true,
+        WriteIndented = true,
+    };
+
+    private static string Serialize(object? value) => JsonSerializer.Serialize(value, ServerJson);
+
+    private static RecDBContext NewDb() => new(
+        TestDbOptions.Create()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options);
+
+    private static PlayerReportingAPI NewApi(RecDBContext db, long? callerId = 6)
+    {
+        var identity = new ClaimsIdentity("TestAuth");
+        if (callerId != null)
+            identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, callerId.Value.ToString()));
+
+        return new PlayerReportingAPI(db)
+        {
+            ControllerContext = new ControllerContext
+            {
+                HttpContext = new DefaultHttpContext { User = new ClaimsPrincipal(identity) }
+            }
+        };
+    }
+
+    /// <summary>Give the controller a request body the way the client sends it.</summary>
+    private static void SetBody(Controller controller, string body, string contentType)
+    {
+        var request = controller.ControllerContext.HttpContext.Request;
+        request.ContentType = contentType;
+        request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
+    }
+
+    private static async Task<RecDBContext> WithProfileAsync(long accountId, string? roles)
+    {
+        var db = NewDb();
+        db.Profiles.Add(new Profile
+        {
+            accountId = accountId,
+            role = roles,
+            username = $"player{accountId}",
+            displayName = $"Player {accountId}",
+            profileImage = DBConfig.DefaultProfileImage
+        });
+        await db.SaveChangesAsync();
+        return db;
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Routes
+    // -----------------------------------------------------------------------------------
+
+    private static string[] PostTemplates(Type controller, string methodName) =>
+        controller.GetMethod(methodName)!.GetCustomAttributes<HttpPostAttribute>()
+            .Select(a => a.Template)
+            .Where(t => t != null)
+            .Select(t => t!)
+            .ToArray();
+
+    [Fact]
+    public void TheWarningRoutesAreTheAbsolutePathsTheClientBuilds()
+    {
+        var create = PostTemplates(typeof(PlayerReportingAPI), nameof(PlayerReportingAPI.CreateWarning));
+        var acknowledge = PostTemplates(typeof(PlayerReportingAPI), nameof(PlayerReportingAPI.AcknowledgeWarning));
+
+        // The client's own literals, verbatim from its metadata string table.
+        Assert.Contains("/api/playerwarnings", create);
+        Assert.Contains("/api/playerwarnings/acknowledge", acknowledge);
+
+        // Every one of them absolute: a template that started with "api/" would be concatenated
+        // onto the controller's "api/PlayerReporting/" prefix and answer a path no client asks for.
+        Assert.All(create.Concat(acknowledge), template => Assert.StartsWith("/", template));
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Issuing a warning
+    // -----------------------------------------------------------------------------------
+
+    [Fact]
+    public async Task AModeratorWarnsAPlayerAndTheModeratorComesFromTheToken()
+    {
+        using var db = await WithProfileAsync(6, "developer,moderator");
+        var api = NewApi(db, 6);
+        SetBody(api, "WarnedPlayerId=205&ReportCategory=101&DisplayReason=Sexual gestures&ModeratorNote=dfg",
+            "application/x-www-form-urlencoded");
+
+        var result = Assert.IsType<OkObjectResult>(await api.CreateWarning());
+        using var json = JsonDocument.Parse(Serialize(result.Value));
+        Assert.True(json.RootElement.GetProperty("Success").GetBoolean());
+
+        var warning = await db.PlayerWarnings.SingleAsync();
+        Assert.Equal(6, warning.ModeratorPlayerId);   // the caller, never a body field
+        Assert.Equal(205, warning.WarnedPlayerId);
+        Assert.Equal(ReportCategory.CoC_Sexual, warning.ReportCategory);
+        Assert.Equal("Sexual gestures", warning.DisplayReason);
+        Assert.Equal("dfg", warning.ModeratorNote);
+        Assert.Null(warning.AcknowledgedAt);
+        Assert.NotEqual(default, warning.CreatedAt);
+    }
+
+    [Fact]
+    public async Task AbsentFieldsAreStoredRatherThanInvented()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        var api = NewApi(db, 6);
+        SetBody(api, "WarnedPlayerId=206", "application/x-www-form-urlencoded");
+
+        Assert.IsType<OkObjectResult>(await api.CreateWarning());
+
+        var warning = await db.PlayerWarnings.SingleAsync();
+        Assert.Equal(0, (int)warning.ReportCategory);
+        Assert.Null(warning.DisplayReason);
+        Assert.Null(warning.ModeratorNote);
+    }
+
+    [Fact]
+    public async Task WarningsAreAppendOnly()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+
+        foreach (var note in new[] { "first", "second" })
+        {
+            var api = NewApi(db, 6);
+            SetBody(api, $"WarnedPlayerId=207&ModeratorNote={note}", "application/x-www-form-urlencoded");
+            Assert.IsType<OkObjectResult>(await api.CreateWarning());
+        }
+
+        var rows = await db.PlayerWarnings.Where(x => x.WarnedPlayerId == 207).OrderBy(x => x.Id).ToListAsync();
+        Assert.Equal(2, rows.Count);
+        Assert.Equal(new[] { "first", "second" }, rows.Select(r => r.ModeratorNote));
+    }
+
+    [Fact]
+    public async Task TheJSONBodyShapeBindsTheSameWayAsTheFormBody()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        var api = NewApi(db, 6);
+        SetBody(api,
+            """{"WarnedPlayerId":"208","ReportCategory":"103","DisplayReason":"griefing","ModeratorNote":"n"}""",
+            "application/json");
+
+        Assert.IsType<OkObjectResult>(await api.CreateWarning());
+
+        var warning = await db.PlayerWarnings.SingleAsync();
+        Assert.Equal(208, warning.WarnedPlayerId);
+        Assert.Equal(ReportCategory.CoC_Trolling, warning.ReportCategory);
+        Assert.Equal("griefing", warning.DisplayReason);
+    }
+
+    [Fact]
+    public async Task AWarningWithoutAWarnedPlayerIsRefused()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        var api = NewApi(db, 6);
+        SetBody(api, "ModeratorNote=dfg", "application/x-www-form-urlencoded");
+
+        Assert.IsType<BadRequestObjectResult>(await api.CreateWarning());
+        Assert.Empty(db.PlayerWarnings);
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("gameClient")]
+    public async Task AValidTokenWithoutAStaffRoleIsRefusedAndNothingIsWritten(string? roles)
+    {
+        using var db = await WithProfileAsync(9, roles);
+        var api = NewApi(db, 9);
+        SetBody(api, "WarnedPlayerId=205", "application/x-www-form-urlencoded");
+
+        var result = Assert.IsType<ObjectResult>(await api.CreateWarning());
+        Assert.Equal(403, result.StatusCode);
+        Assert.Empty(db.PlayerWarnings);
+    }
+
+    [Fact]
+    public async Task APlayerWithNoProfileRowCannotWarnAnyone()
+    {
+        using var db = NewDb();
+        var api = NewApi(db, 6);
+        SetBody(api, "WarnedPlayerId=205", "application/x-www-form-urlencoded");
+
+        var result = Assert.IsType<ObjectResult>(await api.CreateWarning());
+        Assert.Equal(403, result.StatusCode);
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Delivering a warning, and acknowledging it
+    // -----------------------------------------------------------------------------------
+
+    [Fact]
+    public async Task APendingWarningRidesTheNoBanBlockDetailsResponseAsTheWarnScreen()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        var api = NewApi(db, 6);
+        SetBody(api, "WarnedPlayerId=205&ReportCategory=101&DisplayReason=Sexual gestures",
+            "application/x-www-form-urlencoded");
+        Assert.IsType<OkObjectResult>(await api.CreateWarning());
+
+        var warned = NewApi(db, 205);
+        var ok = Assert.IsType<OkObjectResult>(await warned.GetBlockDetails());
+        using var json = JsonDocument.Parse(Serialize(ok.Value));
+
+        Assert.True(json.RootElement.GetProperty("IsWarning").GetBoolean());
+        Assert.False(json.RootElement.GetProperty("IsBan").GetBoolean());
+        // Duration drives the BAN screen whenever it is > 0, so a warning must leave it at 0 or
+        // the player is shown a ban countdown for a warning.
+        Assert.Equal(0, json.RootElement.GetProperty("Duration").GetInt32());
+        Assert.Equal("Sexual gestures", json.RootElement.GetProperty("Message").GetString());
+        Assert.Equal(6, json.RootElement.GetProperty("PlayerIdReporter").GetInt64());
+    }
+
+    [Fact]
+    public async Task AcknowledgingClearsOnlyTheCallersPendingWarnings()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        foreach (var warned in new[] { 205L, 206L })
+        {
+            var api = NewApi(db, 6);
+            SetBody(api, $"WarnedPlayerId={warned}", "application/x-www-form-urlencoded");
+            Assert.IsType<OkObjectResult>(await api.CreateWarning());
+        }
+
+        // The acknowledge posts no body at all on some builds, so this call sends none.
+        var result = Assert.IsType<OkObjectResult>(await NewApi(db, 205).AcknowledgeWarning());
+        using var json = JsonDocument.Parse(Serialize(result.Value));
+        Assert.True(json.RootElement.GetProperty("Success").GetBoolean());
+
+        Assert.NotNull((await db.PlayerWarnings.SingleAsync(x => x.WarnedPlayerId == 205)).AcknowledgedAt);
+        Assert.Null((await db.PlayerWarnings.SingleAsync(x => x.WarnedPlayerId == 206)).AcknowledgedAt);
+    }
+
+    [Fact]
+    public async Task AnAcknowledgedWarningLeavesThePlainEmptyBlockDetails()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        var api = NewApi(db, 6);
+        SetBody(api, "WarnedPlayerId=205", "application/x-www-form-urlencoded");
+        Assert.IsType<OkObjectResult>(await api.CreateWarning());
+
+        Assert.IsType<OkObjectResult>(await NewApi(db, 205).AcknowledgeWarning());
+
+        var ok = Assert.IsType<OkObjectResult>(await NewApi(db, 205).GetBlockDetails());
+        using var json = JsonDocument.Parse(Serialize(ok.Value));
+
+        // Back to the four-key empty object the no-ban response has always been.
+        Assert.Equal(4, json.RootElement.EnumerateObject().Count());
+        Assert.Equal(0, json.RootElement.GetProperty("Duration").GetInt32());
+    }
+
+    [Fact]
+    public async Task ABanOutranksAPendingWarning()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        var api = NewApi(db, 6);
+        SetBody(api, "WarnedPlayerId=205", "application/x-www-form-urlencoded");
+        Assert.IsType<OkObjectResult>(await api.CreateWarning());
+
+        db.Moderation.Add(new ModerationDB
+        {
+            PlayerId = 205,
+            IsBan = true,
+            Message = "banned",
+            Category = ReportCategory.Misc,
+            ExpireDuration = DateTime.UtcNow.AddHours(1)
+        });
+        await db.SaveChangesAsync();
+
+        var ok = Assert.IsType<OkObjectResult>(await NewApi(db, 205).GetBlockDetails());
+        using var json = JsonDocument.Parse(Serialize(ok.Value));
+
+        Assert.False(json.RootElement.GetProperty("IsWarning").GetBoolean());
+        Assert.True(json.RootElement.GetProperty("IsBan").GetBoolean());
+        Assert.True(json.RootElement.GetProperty("Duration").GetInt32() > 0);
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Delivering it: out of the room, into the dorm, and NOT as a chat message
+    // -----------------------------------------------------------------------------------
+
+    /// <summary>
+    /// The static factories <c>RoomUtils</c> and <c>MatchmakingUtils</c> reach for when they are
+    /// called from a request that only has its own context - the same pattern the other
+    /// factory-dependent suites use.
+    /// </summary>
+    private sealed class TestDbContextFactory : IDbContextFactory<RecDBContext>
+    {
+        private readonly DbContextOptions<RecDBContext> options;
+
+        public TestDbContextFactory()
+        {
+            options = TestDbOptions.Create()
+                .UseInMemoryDatabase(Guid.NewGuid().ToString())
+                .Options;
+        }
+
+        public RecDBContext CreateDbContext() => new(options);
+    }
+
+    /// <summary>
+    /// Room 1 (the dorm template, cloned per player) plus a public room the player is standing
+    /// in - the only state that makes an ejection observable.
+    /// </summary>
+    private static async Task<(TestDbContextFactory Factory, RecDBContext Db, RoomInstance Room)>
+        APlayerInARoomAsync(long playerId, bool alreadyInTheirOwnDorm = false)
+    {
+        var factory = new TestDbContextFactory();
+        RoomUtils.DbFactory = factory;
+        MatchmakingUtils.DbFactory = factory;
+
+        var db = factory.CreateDbContext();
+
+        db.Rooms.Add(new RoomData
+        {
+            RoomId = 1,
+            Name = "DormRoom",
+            IsDorm = true,
+            CreatorAccountId = 1,
+            Accessibility = Accessibility.Private,
+            MaxPlayers = 4,
+            CreatedAt = DateTime.UtcNow,
+        });
+        db.SubRooms.Add(new SubRoom
+        {
+            RoomId = 1,
+            Name = "DormRoom",
+            UnitySceneId = "DormRoomScene",
+            MaxPlayers = 4,
+            Accessibility = Accessibility.Private,
+            DataBlob = "",
+        });
+
+        db.Rooms.Add(new RoomData
+        {
+            RoomId = 25,
+            Name = "RecCenter",
+            CreatorAccountId = 1,
+            Accessibility = Accessibility.Public,
+            MaxPlayers = 20,
+            CreatedAt = DateTime.UtcNow,
+        });
+        db.SubRooms.Add(new SubRoom
+        {
+            RoomId = 25,
+            Name = "Home",
+            UnitySceneId = "RecCenterScene",
+            MaxPlayers = 20,
+            Accessibility = Accessibility.Public,
+        });
+
+        // The player's own dorm, for the "already in it" case: a private room they created.
+        if (alreadyInTheirOwnDorm)
+        {
+            db.Rooms.Add(new RoomData
+            {
+                RoomId = 77,
+                Name = "DormRoom",
+                IsDorm = true,
+                CreatorAccountId = playerId,
+                Accessibility = Accessibility.Private,
+                MaxPlayers = 4,
+                CreatedAt = DateTime.UtcNow,
+            });
+            db.SubRooms.Add(new SubRoom
+            {
+                RoomId = 77,
+                Name = "DormRoom",
+                UnitySceneId = "DormRoomScene",
+                MaxPlayers = 4,
+                Accessibility = Accessibility.Private,
+                DataBlob = "",
+            });
+        }
+
+        var instance = new RoomInstance
+        {
+            roomId = alreadyInTheirOwnDorm ? 77 : 25,
+            subRoomId = 0,
+            roomInstanceType = RoomInstanceType.Public,
+            isPrivate = alreadyInTheirOwnDorm,
+            maxCapacity = 20,
+            name = alreadyInTheirOwnDorm ? "^DormRoom" : "^RecCenter",
+            location = alreadyInTheirOwnDorm ? "DormRoomScene" : "RecCenterScene",
+        };
+        db.RoomInstances.Add(instance);
+        await db.SaveChangesAsync();
+
+        db.Presences.Add(new RealPresence
+        {
+            playerId = playerId,
+            isOnline = true,
+            roomInstance = instance.roomInstanceId,
+            errorCode = JoinStatus.Success,
+        });
+        await db.SaveChangesAsync();
+
+        return (factory, db, instance);
+    }
+
+    /// <summary>The room a player's presence currently points at, with the room row behind it.</summary>
+    private static async Task<(RoomInstance Instance, RoomData Room)> WhereIsAsync(RecDBContext db, long playerId)
+    {
+        var presence = await db.Presences.AsNoTracking().FirstAsync(x => x.playerId == playerId);
+        var instance = await db.RoomInstances.AsNoTracking().FirstAsync(x => x.roomInstanceId == presence.roomInstance);
+        var room = await db.Rooms.AsNoTracking().FirstAsync(x => x.RoomId == instance.roomId);
+        return (instance, room);
+    }
+
+    [Fact]
+    public async Task AWarningIsNotDeliveredAsACoachMessage()
+    {
+        var (factory, db, _) = await APlayerInARoomAsync(205);
+
+        // Notify.DbFactory is wired to the SAME store on purpose. With it null, SendMessage returns
+        // immediately and the assertion below would pass even if a warning still tried to deliver
+        // itself as a coach message; with it pointed somewhere else, the row would land in the other
+        // database. Pointing it at this store is what makes "no message was written" mean it.
+        var previousFactory = Notify.DbFactory;
+        try
+        {
+            Notify.DbFactory = factory;
+
+            await WithModeratorAsync(db, warnedPlayerId: 205);
+
+            Assert.Empty(await db.Messages.ToListAsync());
+
+            // Positive control: this exact wiring does see a message when one is sent, so the empty
+            // result above is the warning's doing rather than a harness that cannot see writes.
+            await Notify.SendMessage(205, new Message
+            {
+                Type = MessageType.CoachMessage,
+                Data = "control",
+                FromPlayerId = 1,
+            });
+            Assert.Single(await db.Messages.ToListAsync());
+        }
+        finally
+        {
+            Notify.DbFactory = previousFactory;
+        }
+    }
+
+    [Fact]
+    public async Task AWarningTakesThePlayerOutOfTheRoomTheyAreInAndIntoTheirDorm()
+    {
+        const long playerId = 205;
+        var (_, db, wasIn) = await APlayerInARoomAsync(playerId);
+
+        await WithModeratorAsync(db, warnedPlayerId: playerId);
+
+        var (nowIn, room) = await WhereIsAsync(db, playerId);
+
+        // Out of the room they were warned in...
+        Assert.NotEqual(wasIn.roomInstanceId, nowIn.roomInstanceId);
+
+        // ...and standing in their own dorm, which is what makes them face the warn screen on the
+        // room load that follows.
+        Assert.True(room.IsDorm);
+        Assert.Equal(playerId, room.CreatorAccountId);
+    }
+
+    [Fact]
+    public async Task AWarningDoesNotBounceAPlayerOutOfTheirOwnDorm()
+    {
+        const long playerId = 206;
+        var (_, db, wasIn) = await APlayerInARoomAsync(playerId, alreadyInTheirOwnDorm: true);
+
+        await WithModeratorAsync(db, warnedPlayerId: playerId);
+
+        var (nowIn, room) = await WhereIsAsync(db, playerId);
+
+        Assert.Equal(wasIn.roomInstanceId, nowIn.roomInstanceId);
+        Assert.True(room.IsDorm);
+    }
+
+    /// <summary>A moderator issues a warning to <paramref name="warnedPlayerId"/> through the route.</summary>
+    private static async Task WithModeratorAsync(RecDBContext db, long warnedPlayerId)
+    {
+        // Only once: the moderator row has accountId as its key, so a second call for a second
+        // warning would be a duplicate insert rather than a second warn.
+        if (!await db.Profiles.AnyAsync(x => x.accountId == 6))
+        {
+            db.Profiles.Add(new Profile
+            {
+                accountId = 6,
+                role = "moderator",
+                username = "mod",
+                displayName = "Mod",
+                profileImage = DBConfig.DefaultProfileImage
+            });
+            await db.SaveChangesAsync();
+        }
+
+        var api = NewApi(db, 6);
+        SetBody(api, $"WarnedPlayerId={warnedPlayerId}&ReportCategory=101", "application/x-www-form-urlencoded");
+        Assert.IsType<OkObjectResult>(await api.CreateWarning());
+    }
+
+    /// <summary>Adds the developer role a target needs to be asked before anything is applied.</summary>
+    private static async Task WithDeveloperProfileAsync(RecDBContext db, long accountId)
+    {
+        db.Profiles.Add(new Profile
+        {
+            accountId = accountId,
+            role = "developer",
+            username = $"dev{accountId}",
+            displayName = $"Dev {accountId}",
+            profileImage = DBConfig.DefaultProfileImage
+        });
+        await db.SaveChangesAsync();
+    }
+
+    /// <summary>Posts one voteToKick body as <paramref name="callerId"/> and requires it to be accepted.</summary>
+    private static async Task AnswerVoteKickAsync(RecDBContext db, long callerId, string body)
+    {
+        var api = NewApi(db, callerId);
+        SetBody(api, body, "application/x-www-form-urlencoded");
+
+        // The route is declared ActionResult<OkResponse>, so the object result is on .Result.
+        var result = await api.VoteToKick();
+        var ok = Assert.IsType<OkObjectResult>(result.Result);
+        Assert.True(((OkResponse)ok.Value!).Success);
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Cannot be bypassed: a pending warning holds the player in their dorm until they
+    // acknowledge it. This is the whole point of the feature - the row alone is not enough,
+    // because leaving the dorm used to clear nothing and block nothing.
+    // -----------------------------------------------------------------------------------
+
+    [Fact]
+    public async Task APendingWarningAnswersTheRoomJoinWithTheirDormInsteadOfTheRoomTheyAskedFor()
+    {
+        const long playerId = 220;
+        var (_, db, wasIn) = await APlayerInARoomAsync(playerId);
+
+        await WithModeratorAsync(db, warnedPlayerId: playerId);
+
+        // The play-menu join, which is also what goto/room/{name} and matchmake/room/{id} run.
+        var match = await MatchmakingUtils.Matchmake(JoinMode.PublicMatchmaking, "RecCenter", playerId);
+
+        // Answered as a successful matchmake into the dorm rather than as an error, so the client
+        // loads the dorm it is already in with the warning screen still up.
+        Assert.Equal(JoinStatus.Success, match.errorCode);
+        Assert.NotNull(match.roomInstance);
+
+        var (nowIn, room) = await WhereIsAsync(db, playerId);
+        Assert.True(room.IsDorm);
+        Assert.Equal(playerId, room.CreatorAccountId);
+        Assert.Equal(match.roomInstance!.roomInstanceId, nowIn.roomInstanceId);
+        Assert.NotEqual(wasIn.roomInstanceId, nowIn.roomInstanceId);
+    }
+
+    [Fact]
+    public async Task APendingWarningAlsoHoldsTheInstanceIdJoinsShut()
+    {
+        const long playerId = 221;
+        var (_, db, wasIn) = await APlayerInARoomAsync(playerId);
+
+        await WithModeratorAsync(db, warnedPlayerId: playerId);
+
+        // JoinRoom is the funnel behind a friend's presence, an invite, a deep link, a clubhouse and
+        // an event - the doors that used to let a warned player walk straight back out.
+        var match = await MatchmakingUtils.JoinRoom(playerId, wasIn.roomInstanceId);
+
+        var (nowIn, room) = await WhereIsAsync(db, playerId);
+        Assert.True(room.IsDorm);
+        Assert.NotEqual(wasIn.roomInstanceId, nowIn.roomInstanceId);
+        Assert.Equal(match.roomInstance!.roomInstanceId, nowIn.roomInstanceId);
+    }
+
+    [Fact]
+    public async Task AcknowledgingIsWhatLiftsTheHoldNotLeavingTheDorm()
+    {
+        const long playerId = 222;
+        var (_, db, _) = await APlayerInARoomAsync(playerId);
+
+        await WithModeratorAsync(db, warnedPlayerId: playerId);
+
+        // Still pending: the warning was delivered, not answered.
+        Assert.True(await db.HasPendingWarningAsync(playerId));
+        var held = await MatchmakingUtils.Matchmake(JoinMode.PublicMatchmaking, "RecCenter", playerId);
+        Assert.True((await db.Rooms.AsNoTracking().FirstAsync(x => x.RoomId == held.roomInstance!.roomId)).IsDorm);
+
+        Assert.IsType<OkObjectResult>(await NewApi(db, playerId).AcknowledgeWarning());
+
+        var released = await MatchmakingUtils.Matchmake(JoinMode.PublicMatchmaking, "RecCenter", playerId);
+        var room = await db.Rooms.AsNoTracking().FirstAsync(x => x.RoomId == released.roomInstance!.roomId);
+        Assert.Equal("RecCenter", room.Name);
+    }
+
+    [Fact]
+    public async Task APendingWarningStillLetsThePlayerIntoTheirOwnDorm()
+    {
+        const long playerId = 223;
+        var (_, db, _) = await APlayerInARoomAsync(playerId, alreadyInTheirOwnDorm: true);
+
+        await WithModeratorAsync(db, warnedPlayerId: playerId);
+
+        // Their own dorm is where the warning is answered, so it is not held shut - a warned player
+        // has to be able to get back into the room the warning screen lives in.
+        var match = await MatchmakingUtils.Matchmake(JoinMode.PublicMatchmaking, "DormRoom", playerId);
+
+        Assert.Equal(JoinStatus.Success, match.errorCode);
+        Assert.NotNull(match.roomInstance);
+
+        var room = await db.Rooms.AsNoTracking().FirstAsync(x => x.RoomId == match.roomInstance!.roomId);
+        Assert.True(room.IsDorm);
+        Assert.Equal(playerId, room.CreatorAccountId);
+    }
+
+    [Fact]
+    public void TheServedWarningKeepsDurationAtZeroAndOnlyTheDeliveryCarriesTheScreenHold()
+    {
+        var warning = new PlayerWarning
+        {
+            Id = 1,
+            ModeratorPlayerId = 6,
+            WarnedPlayerId = 205,
+            DisplayReason = "Sexual gestures",
+        };
+
+        var served = PlayerUtils.BuildWarningBlockDetails(warning);
+        var delivered = PlayerUtils.BuildWarningBlockDetails(warning, (int)PlayerUtils.WarningScreenHold.TotalSeconds);
+
+        // What moderationBlockDetails answers with: the warn screen's text, and no duration - the
+        // pending state is not a timeout.
+        Assert.True(served.IsWarning);
+        Assert.False(served.IsBan);
+        Assert.Equal(0, served.Duration);
+        Assert.Equal("Sexual gestures", served.Message);
+
+        // What is pushed at the client: the client only holds the dorm's screen up (and so only ever
+        // asks its warn screen for text) when the delivered frame carries Duration > 0. IsBan stays
+        // false, which is what keeps it the warn screen and not the ban screen.
+        Assert.True(delivered.IsWarning);
+        Assert.False(delivered.IsBan);
+        Assert.True(delivered.Duration > 0);
+        Assert.Equal("Sexual gestures", delivered.Message);
+    }
+
+    [Fact]
+    public async Task AWarningIssuedWhileThePlayerIsOfflineStaysPending()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+
+        // Player 205 has no presence row at all, and no notify connection is registered, so both the
+        // presence push and the two frames are dropped. The warning is written BEFORE either, which
+        // is why a player who is offline when they are warned is still held when they come back.
+        await WithModeratorAsync(db, 205);
+
+        Assert.True(await db.HasPendingWarningAsync(205));
+        Assert.Empty(await db.Messages.ToListAsync());
+    }
+
+    [Fact]
+    public async Task WarningsStackAndOneAcknowledgementClearsThemAll()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+
+        await WithModeratorAsync(db, 224);
+        await WithModeratorAsync(db, 224);
+
+        var rows = await db.PlayerWarnings.Where(x => x.WarnedPlayerId == 224).ToListAsync();
+        Assert.Equal(2, rows.Count);
+        Assert.All(rows, row => Assert.Null(row.AcknowledgedAt));
+
+        Assert.IsType<OkObjectResult>(await NewApi(db, 224).AcknowledgeWarning());
+
+        Assert.False(await db.HasPendingWarningAsync(224));
+    }
+
+    [Fact]
+    public async Task ASecondAcknowledgementIsANoOpRatherThanAnError()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        await WithModeratorAsync(db, 225);
+
+        Assert.IsType<OkObjectResult>(await NewApi(db, 225).AcknowledgeWarning());
+
+        // The button is already pressed, or the screen was re-opened after it closed: the second
+        // post has nothing left to clear and must still succeed, or the client hangs on its screen.
+        Assert.IsType<OkObjectResult>(await NewApi(db, 225).AcknowledgeWarning());
+        Assert.NotNull((await db.PlayerWarnings.SingleAsync()).AcknowledgedAt);
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Developers: the server asks, waits, and only then applies.
+    // -----------------------------------------------------------------------------------
+
+    [Fact]
+    public async Task AWarningForADeveloperIsParkedAndNothingIsWritten()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        await WithDeveloperProfileAsync(db, 230);
+
+        var api = NewApi(db, 6);
+        SetBody(api, "WarnedPlayerId=230&ReportCategory=101&DisplayReason=Sexual gestures&ModeratorNote=dfg",
+            "application/x-www-form-urlencoded");
+        Assert.IsType<OkObjectResult>(await api.CreateWarning());
+
+        // Parked, not issued: a warning that exists is a warning that pins its player to the dorm,
+        // and the developer has not decided whether to accept it.
+        Assert.Empty(await db.PlayerWarnings.ToListAsync());
+
+        var decision = PlayerUtils.TakeDeveloperDecision(230);
+        Assert.NotNull(decision);
+        Assert.Equal(PlayerUtils.DeveloperDecisionKind.Warning, decision!.Kind);
+        Assert.Equal("Sexual gestures", decision.DisplayReason);
+        Assert.Equal("dfg", decision.ModeratorNote);
+        Assert.Equal(6, decision.IssuedBy);
+    }
+
+    [Fact]
+    public async Task ADeveloperAcceptingTheWarningGetsItWrittenAsTheModeratorsWarning()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        await WithDeveloperProfileAsync(db, 231);
+        await WithModeratorAsync(db, 231);
+
+        await AnswerVoteKickAsync(db, 231, "PlayerId=231&Response=true&GameSessionId=9301");
+
+        var warning = await db.PlayerWarnings.SingleAsync();
+        Assert.Equal(231, warning.WarnedPlayerId);
+        Assert.Equal(6, warning.ModeratorPlayerId);   // the moderator who issued it, not the developer who accepted
+        Assert.Equal(ReportCategory.CoC_Sexual, warning.ReportCategory);
+
+        // Accepting is not acknowledging: the warning is delivered now and stays pending until the
+        // developer presses acknowledge on the warn screen.
+        Assert.Null(warning.AcknowledgedAt);
+        Assert.True(await db.HasPendingWarningAsync(231));
+    }
+
+    [Fact]
+    public async Task ADeveloperDenyingTheWarningLeavesNothingBehind()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        await WithDeveloperProfileAsync(db, 232);
+        await WithModeratorAsync(db, 232);
+
+        await AnswerVoteKickAsync(db, 232, "PlayerId=232&Response=false&GameSessionId=9302");
+
+        // Deny means deny: no warning to hold them, no moderation row, nothing pending to clear.
+        Assert.Empty(await db.PlayerWarnings.ToListAsync());
+        Assert.Empty(await db.Moderation.ToListAsync());
+        Assert.False(await db.HasPendingWarningAsync(232));
+        Assert.Null(PlayerUtils.TakeDeveloperDecision(232));
+    }
+
+    [Fact]
+    public async Task ARepeatedAnswerCannotApplyTheWarningTwice()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        await WithDeveloperProfileAsync(db, 233);
+        await WithModeratorAsync(db, 233);
+
+        await AnswerVoteKickAsync(db, 233, "PlayerId=233&Response=true&GameSessionId=9303");
+        await AnswerVoteKickAsync(db, 233, "PlayerId=233&Response=true&GameSessionId=9303");
+
+        Assert.Single(await db.PlayerWarnings.ToListAsync());
+    }
+
+    /// <summary>
+    /// A parked prompt whose developer is not connected can no longer be answered, so it must not
+    /// keep the slot. It used to: the client that would have shown the dialog was gone, nothing was
+    /// written when the action was parked, and every later warning aimed at that developer was
+    /// dropped with only a console line - the panel reported a prompt as sent and the developer's
+    /// client was never asked anything again for the life of the process.
+    /// </summary>
+    [Fact]
+    public async Task ADeveloperPromptNothingCouldReceiveIsReplacedInsteadOfWedging()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        await WithDeveloperProfileAsync(db, 234);
+
+        var warning = new PlayerWarning { WarnedPlayerId = 234, DisplayReason = "Trolling" };
+        Assert.True(await PlayerUtils.DeferForDeveloperAsync(
+            db, 234, PlayerUtils.DeveloperDecisionKind.Warning, PlayerUtils.BuildWarningBlockDetails(warning, 60)));
+        Assert.Null(Notify.GetClient(234));   // no live notify connection anywhere in this test
+
+        var kick = PlayerUtils.BuildBlockDetails(true, ReportCategory.VoteKick, "kicked", DateTime.UtcNow.AddMinutes(15));
+        Assert.True(await PlayerUtils.DeferForDeveloperAsync(db, 234, PlayerUtils.DeveloperDecisionKind.Kick, kick));
+
+        // The replacement is what the developer is asked about, so their answer applies the action
+        // the moderator just issued instead of the one nobody could have read.
+        var decision = PlayerUtils.TakeDeveloperDecision(234);
+        Assert.NotNull(decision);
+        Assert.Equal(PlayerUtils.DeveloperDecisionKind.Kick, decision!.Kind);
+    }
+
+    /// <summary>
+    /// The other half of the same rule: a developer who IS connected keeps the prompt they were
+    /// already shown. Replacing a readable prompt would mean the developer reads one action and
+    /// their answer applies a different one - the client answers with only the player's id.
+    /// </summary>
+    [Fact]
+    public async Task AConnectedDeveloperKeepsThePromptTheyWereAlreadyShown()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        await WithDeveloperProfileAsync(db, 235);
+
+        var client = new HubClient { AccountId = 235, ConnectionId = "warning-test-235" };
+        Notify.Clients.Add(client);
+        try
+        {
+            var warning = new PlayerWarning { WarnedPlayerId = 235, DisplayReason = "Trolling" };
+            Assert.True(await PlayerUtils.DeferForDeveloperAsync(
+                db, 235, PlayerUtils.DeveloperDecisionKind.Warning, PlayerUtils.BuildWarningBlockDetails(warning, 60)));
+
+            var kick = PlayerUtils.BuildBlockDetails(true, ReportCategory.VoteKick, "kicked", DateTime.UtcNow.AddMinutes(15));
+            Assert.True(await PlayerUtils.DeferForDeveloperAsync(db, 235, PlayerUtils.DeveloperDecisionKind.Kick, kick));
+
+            Assert.Equal(PlayerUtils.DeveloperDecisionKind.Warning, PlayerUtils.TakeDeveloperDecision(235)!.Kind);
+        }
+        finally
+        {
+            Notify.Clients.Remove(client);
+        }
+    }
+
+    [Fact]
+    public async Task AnAnswerWithNothingParkedIsStable()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        await WithDeveloperProfileAsync(db, 234);
+
+        // A late answer (the decision expired), a duplicate, or a response that arrives after the
+        // player reconnected: nothing is parked, so there is nothing to apply and nothing to crash.
+        await AnswerVoteKickAsync(db, 234, "PlayerId=234&Response=true&GameSessionId=9304");
+
+        Assert.Empty(await db.PlayerWarnings.ToListAsync());
+        Assert.Empty(await db.Moderation.ToListAsync());
+    }
+
+    [Fact]
+    public async Task AVoteKickThatReachesADeveloperIsParkedUntilTheyAcceptIt()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        await WithDeveloperProfileAsync(db, 235);
+
+        const string vote = "PlayerId=235&Response=true&GameSessionId=9305&Reason=Griefing";
+        foreach (var voter in new[] { 301L, 302L, 303L })
+            await AnswerVoteKickAsync(db, voter, vote);
+
+        // The threshold was reached against a developer and nothing happened to them yet.
+        Assert.Empty(await db.Moderation.ToListAsync());
+
+        await AnswerVoteKickAsync(db, 235, "PlayerId=235&Response=true&GameSessionId=9305");
+
+        // Accepted: the kick is applied for real, which is the delivery the park skipped.
+        Assert.Single(await db.Moderation.ToListAsync());
+    }
+
+    // -----------------------------------------------------------------------------------
+    // The write envelope
+    // -----------------------------------------------------------------------------------
+
+    [Fact]
+    public async Task TheWriteEnvelopeAnswersBothKeyCasingsWithAnEmptyError()
+    {
+        using var db = await WithProfileAsync(6, "moderator");
+        var api = NewApi(db, 6);
+        SetBody(api, "WarnedPlayerId=205", "application/x-www-form-urlencoded");
+
+        var ok = Assert.IsType<OkObjectResult>(await api.CreateWarning());
+        using var json = JsonDocument.Parse(Serialize(ok.Value));
+
+        // This server answers its report write in PascalCase; the reference implementation
+        // documents lowercase for this one. Newtonsoft ignores what it has no member for, so both
+        // are served rather than betting on one.
+        Assert.True(json.RootElement.GetProperty("Success").GetBoolean());
+        Assert.True(json.RootElement.GetProperty("success").GetBoolean());
+        Assert.Equal("", json.RootElement.GetProperty("Error").GetString());
+        Assert.Equal("", json.RootElement.GetProperty("error").GetString());
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Releasing the hold, and the reason the warn screen is filed under
+    // -----------------------------------------------------------------------------------
+
+    /// <summary>
+    /// The frame an acknowledgement pushes is the "nothing is pending against you" state, not a
+    /// second warning. The client's dorm hold is a coroutine started by the duration on the kick
+    /// frame, and the state it is handed on acknowledgement is what it renders: a cleared block
+    /// must therefore raise neither the warn screen nor the ban screen - IsWarning and IsBan both
+    /// false, Duration 0 - or acknowledging a warning would re-raise a moderation screen instead
+    /// of closing one.
+    /// </summary>
+    [Fact]
+    public void TheAcknowledgedStateRaisesNeitherScreen()
+    {
+        var cleared = PlayerUtils.BuildClearedBlockDetails();
+
+        Assert.False(cleared.IsWarning);
+        Assert.False(cleared.IsBan);
+        Assert.False(cleared.IsHostKick);
+        Assert.Equal(0, cleared.Duration);
+        Assert.Equal(string.Empty, cleared.Message);
+        Assert.Equal(ReportCategory.Unknown, cleared.ReportCategory);
+    }
+
+    /// <summary>
+    /// The sixth Code of Conduct reason has to be 200, because that is the number the 2023
+    /// client's category enum carries for it (KOFEKCMPOEK.DHGJGCOMKOM.InappropriateClothing = 200)
+    /// and the warn screen picks the reason it renders from that number. A different value would
+    /// file the warning correctly on the server and show the player the wrong reason - and the
+    /// admin panel's warn route validates on the same enum, so it has to be defined on both.
+    /// </summary>
+    [Fact]
+    public void TheCustomClothingReasonIsTheNumberOfTheClientEnum()
+    {
+        Assert.Equal(200, (int)ReportCategory.InappropriateClothing);
+        Assert.Equal(200, (int)KickReason.InappropriateClothing);
+
+        // What the panel's category validation (Enum.IsDefined) and the warn write both read.
+        Assert.True(Enum.IsDefined(typeof(ReportCategory), 200));
+        Assert.True(Enum.IsDefined(typeof(KickReason), 200));
+
+        // The five original reasons keep the numbers they already had: the panel and the client
+        // both address them by number.
+        Assert.Equal(100, (int)ReportCategory.CoC_Underage);
+        Assert.Equal(101, (int)ReportCategory.CoC_Sexual);
+        Assert.Equal(102, (int)ReportCategory.CoC_Discrimination);
+        Assert.Equal(103, (int)ReportCategory.CoC_Trolling);
+        Assert.Equal(104, (int)ReportCategory.CoC_NameOrProfile);
+    }
+}