From 6a2ca6f9e769294dba820f4eaecda2c909346c41 Mon Sep 17 00:00:00 2001 From: ipax77 Date: Sat, 7 Nov 2026 08:26:16 +0100 Subject: [PATCH 1/5] Fix replay pagination resetting to the first page --- .../Replays/ReplaysComponent.razor | 15 +- .../Replays/ReplaysRequestComponent.razor | 5 + .../dsstats.tests/ReplayPagination.Tests.cs | 154 ++++++++++++++++++ 3 files changed, 171 insertions(+), 3 deletions(-) create mode 100644 src/tests/dsstats.tests/ReplayPagination.Tests.cs diff --git a/src/common/dsstats.weblib/Replays/ReplaysComponent.razor b/src/common/dsstats.weblib/Replays/ReplaysComponent.razor index df4244a05..1a2ac9a71 100644 --- a/src/common/dsstats.weblib/Replays/ReplaysComponent.razor +++ b/src/common/dsstats.weblib/Replays/ReplaysComponent.razor @@ -183,7 +183,8 @@ { SetReplayUserRatingRequestOptions(); replaysCount = await ReplayRepository.GetReplaysCount(ReplaysRequest); - ReplaysRequest.Page = 1; + var totalPages = Math.Max(1, (int)Math.Ceiling((double)replaysCount / ReplaysRequest.PageSize)); + ReplaysRequest.Page = Math.Clamp(ReplaysRequest.Page, 1, totalPages); if (virtualizeComponent != null && replaysCount > 0) { await virtualizeComponent.RefreshDataAsync(); @@ -199,13 +200,20 @@ private async ValueTask> LoadReplays(ItemsProviderRequest request) { - var numReplays = Math.Min(request.Count, replaysCount - request.StartIndex); + var pageCount = Math.Min(ReplaysRequest.PageSize, + Math.Max(0, replaysCount - (ReplaysRequest.Page - 1) * ReplaysRequest.PageSize)); + var numReplays = Math.Min(request.Count, Math.Max(0, pageCount - request.StartIndex)); + if (numReplays == 0) + { + latestResponse = []; + return new ItemsProviderResult([], pageCount); + } ReplaysRequest.Skip = request.StartIndex; ReplaysRequest.Take = numReplays; SetReplayUserRatingRequestOptions(); var replays = await ReplayRepository.GetReplays(ReplaysRequest, request.CancellationToken); latestResponse = replays; - return new ItemsProviderResult(replays, Math.Min(replaysCount, ReplaysRequest.PageSize)); + return new ItemsProviderResult(replays, pageCount); } private async Task SortList(MouseEventArgs e, string column) @@ -234,6 +242,7 @@ Ascending = exOrder == null ? false : !exOrder.Ascending }); } + ReplaysRequest.Page = 1; await Reload(); } diff --git a/src/common/dsstats.weblib/Replays/ReplaysRequestComponent.razor b/src/common/dsstats.weblib/Replays/ReplaysRequestComponent.razor index fb29fb558..a3b2c997c 100644 --- a/src/common/dsstats.weblib/Replays/ReplaysRequestComponent.razor +++ b/src/common/dsstats.weblib/Replays/ReplaysRequestComponent.razor @@ -153,18 +153,21 @@ private void FieldChanged(object? sender, FieldChangedEventArgs e) { + Request.Page = 1; OnRequestChanged.InvokeAsync(); } private void ClearCommanders() { Request.Commander = string.Empty; + Request.Page = 1; OnRequestChanged.InvokeAsync(); } private void ClearNames() { Request.Name = string.Empty; + Request.Page = 1; OnRequestChanged.InvokeAsync(); } @@ -175,6 +178,7 @@ Request.LinkCommanders = false; replayFiliterModal?.filter.Reset(); Request.Filter = null; + Request.Page = 1; OnRequestChanged.InvokeAsync(); } @@ -247,6 +251,7 @@ private void FilterRequest(ReplaysFilter? filter) { Request.Filter = filter; + Request.Page = 1; OnRequestChanged.InvokeAsync(); } diff --git a/src/tests/dsstats.tests/ReplayPagination.Tests.cs b/src/tests/dsstats.tests/ReplayPagination.Tests.cs new file mode 100644 index 000000000..90afd9f4d --- /dev/null +++ b/src/tests/dsstats.tests/ReplayPagination.Tests.cs @@ -0,0 +1,154 @@ +using dsstats.shared; +using dsstats.shared.Interfaces; +using dsstats.weblib.Replays; +using Microsoft.AspNetCore.Components; +using Microsoft.AspNetCore.Components.Rendering; +using Microsoft.AspNetCore.Components.RenderTree; +using Microsoft.AspNetCore.Components.Web.Virtualization; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.JSInterop; +using Moq; + +namespace dsstats.tests; + +[TestClass] +public class ReplayPaginationTests +{ + [TestMethod] + public async Task PageChangeSurvivesReloadAndLoadsDifferentReplays() + { + await using var fixture = new Fixture(); + await fixture.Render(); + var first = await fixture.Load(0, 50); + + fixture.Request.Page = 2; + await fixture.Reload(); + var second = await fixture.Load(0, 50); + + Assert.AreEqual(2, fixture.Request.Page); + Assert.AreEqual(10, second.TotalItemCount); + Assert.HasCount(10, second.Items); + Assert.AreEqual("replay-0", first.Items.First().ReplayHash); + Assert.AreEqual("replay-10", second.Items.First().ReplayHash); + Assert.AreEqual((2, 0, 10), fixture.Reads.Last()); + + fixture.Request.Page = 1; + await fixture.Reload(); + Assert.AreEqual("replay-0", (await fixture.Load(0, 50)).Items.First().ReplayHash); + } + + [TestMethod] + public async Task LastPageUsesRemainingCountAndDoesNotReadPastItsEnd() + { + await using var fixture = new Fixture(); + await fixture.Render(); + fixture.Request.Page = 3; + await fixture.Reload(); + + var remaining = await fixture.Load(1, 50); + Assert.AreEqual(3, remaining.TotalItemCount); + CollectionAssert.AreEqual(new[] { "replay-21", "replay-22" }, + remaining.Items.Select(x => x.ReplayHash).ToArray()); + Assert.AreEqual((3, 1, 2), fixture.Reads.Single()); + + var pastEnd = await fixture.Load(10, 50); + Assert.AreEqual(3, pastEnd.TotalItemCount); + Assert.IsEmpty(pastEnd.Items); + Assert.HasCount(1, fixture.Reads); + } + + [TestMethod] + [DataRow(12, 2)] + [DataRow(0, 1)] + public async Task ReloadClampsPageWhenReplaysAreRemoved(int count, int expectedPage) + { + await using var fixture = new Fixture(); + await fixture.Render(); + fixture.Request.Page = 3; + fixture.Count = count; + + await fixture.Reload(); + + Assert.AreEqual(expectedPage, fixture.Request.Page); + } + +#pragma warning disable BL0006 // Inspect the real callbacks while omitting modal/JS rendering, as in the lifecycle tests. + private sealed class Fixture : IAsyncDisposable + { + private readonly ServiceProvider services; + private readonly PaginationRenderer renderer; + public ReplaysRequest Request { get; } = new() { PageSize = 10 }; + public int Count { get; set; } = 23; + public List<(int Page, int Skip, int Take)> Reads { get; } = []; + + public Fixture() + { + var repository = new Mock(); + repository.Setup(x => x.GetReplaysCount(It.IsAny(), It.IsAny())) + .ReturnsAsync(() => Count); + repository.Setup(x => x.GetReplays(It.IsAny(), It.IsAny())) + .ReturnsAsync((ReplaysRequest request, CancellationToken _) => + { + Reads.Add((request.Page, request.Skip, request.Take)); + int offset = (request.Page - 1) * request.PageSize + request.Skip; + return Enumerable.Range(offset, Math.Max(0, Math.Min(request.Take, Count - offset))) + .Select(i => new ReplayListDto { ReplayHash = $"replay-{i}" }).ToList(); + }); + services = new ServiceCollection().AddLogging().AddOptions() + .AddSingleton(repository.Object).AddSingleton(Mock.Of()).BuildServiceProvider(); + renderer = new PaginationRenderer(services); + } + + public Task Render() => renderer.Dispatcher.InvokeAsync(() => renderer.Render(Request)); + public Task Reload() => renderer.Dispatcher.InvokeAsync(() => renderer.Component.Reload.InvokeAsync()); + public Task> Load(int start, int count) => + renderer.Dispatcher.InvokeAsync(() => renderer.Component.Provider!(new(start, count, default)).AsTask()); + + public async ValueTask DisposeAsync() + { + await renderer.DisposeAsync(); + await services.DisposeAsync(); + } + } + + public sealed class HeadlessReplays : ReplaysComponent + { + public EventCallback Reload { get; private set; } + public ItemsProviderDelegate? Provider { get; private set; } + + protected override void BuildRenderTree(RenderTreeBuilder builder) + { + using var tree = new RenderTreeBuilder(); + base.BuildRenderTree(tree); + var frames = tree.GetFrames(); + for (int i = 0; i < frames.Count; i++) + { + var frame = frames.Array[i]; + if (frame.FrameType != RenderTreeFrameType.Attribute) continue; + if (frame.AttributeName == nameof(ReplaysRequestComponent.OnRequestChanged)) + Reload = (EventCallback)frame.AttributeValue; + if (frame.AttributeName == "ItemsProvider") + Provider = (ItemsProviderDelegate)frame.AttributeValue; + } + } + } + + private sealed class PaginationRenderer : Renderer + { + private readonly int componentId; + public HeadlessReplays Component { get; } + public override Dispatcher Dispatcher { get; } = Dispatcher.CreateDefault(); + public PaginationRenderer(IServiceProvider services) : base(services, services.GetRequiredService()) + { + Component = (HeadlessReplays)InstantiateComponent(typeof(HeadlessReplays)); + componentId = AssignRootComponentId(Component); + } + + public Task Render(ReplaysRequest request) => RenderRootComponentAsync(componentId, + ParameterView.FromDictionary(new Dictionary { [nameof(ReplaysComponent.ReplaysRequest)] = request })); + protected override void HandleException(Exception exception) => throw new InvalidOperationException("Replay rendering failed.", exception); + protected override Task UpdateDisplayAsync(in RenderBatch renderBatch) => Task.CompletedTask; + } +#pragma warning restore BL0006 +} From 4c3aeac8813e532d3e353f4ba13e7ad06ee1d5d5 Mon Sep 17 00:00:00 2001 From: ipax77 Date: Sat, 7 Nov 2026 08:39:40 +0100 Subject: [PATCH 2/5] Delete owned player upgrades when deduplicating replays --- .../dsstats.api/Services/TransitionService.cs | 2 + .../ImportService.Duplicates.cs | 2 + .../ImportServiceDuplicates.Tests.cs | 206 ++++++++++++++++++ 3 files changed, 210 insertions(+) create mode 100644 src/tests/dsstats.tests/ImportServiceDuplicates.Tests.cs diff --git a/src/server/dsstats.api/Services/TransitionService.cs b/src/server/dsstats.api/Services/TransitionService.cs index 417514792..067f405e5 100644 --- a/src/server/dsstats.api/Services/TransitionService.cs +++ b/src/server/dsstats.api/Services/TransitionService.cs @@ -162,6 +162,8 @@ private async Task DeleteReplay(string replayHash, DsstatsContext context) { return; } + // The optional upgrade relationship otherwise leaves rows with a null ReplayPlayerId. + context.PlayerUpgrades.RemoveRange(replay.Players.SelectMany(player => player.Upgrades)); context.Replays.Remove(replay); await context.SaveChangesAsync(); logger.LogWarning($"Deleted replay {replayHash}"); diff --git a/src/server/dsstats.dbServices/ImportService.Duplicates.cs b/src/server/dsstats.dbServices/ImportService.Duplicates.cs index c061a9569..01206f299 100644 --- a/src/server/dsstats.dbServices/ImportService.Duplicates.cs +++ b/src/server/dsstats.dbServices/ImportService.Duplicates.cs @@ -120,6 +120,8 @@ private static async Task DeleteReplay(string replayHash, DsstatsContext context if (replay is not null) { + // The optional upgrade relationship otherwise leaves rows with a null ReplayPlayerId. + context.PlayerUpgrades.RemoveRange(replay.Players.SelectMany(player => player.Upgrades)); context.Replays.Remove(replay); await context.SaveChangesAsync(); } diff --git a/src/tests/dsstats.tests/ImportServiceDuplicates.Tests.cs b/src/tests/dsstats.tests/ImportServiceDuplicates.Tests.cs new file mode 100644 index 000000000..82d6e75d0 --- /dev/null +++ b/src/tests/dsstats.tests/ImportServiceDuplicates.Tests.cs @@ -0,0 +1,206 @@ +using dsstats.api.Services; +using dsstats.db; +using dsstats.dbServices; +using dsstats.shared; +using dsstats.shared.Interfaces; +using Microsoft.Data.Sqlite; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging.Abstractions; +using Moq; + +namespace dsstats.tests; + +[TestClass] +public sealed class ImportServiceDuplicatesTests +{ + [TestMethod] + public async Task LongerReplayReplacementDeletesOldUpgradesAndPreservesOtherReplays() + { + await using var fixture = await Fixture.Create(); + var original = CreateReplay("Direct Strike", 800, 100); + var unrelated = CreateReplay("Another match", 900, 300, dayOffset: 1); + await fixture.Importer.InsertReplays([original, unrelated]); + var oldUpgrades = await fixture.Upgrades(original.ComputeHash()); + var unrelatedUpgrades = await fixture.Upgrades(unrelated.ComputeHash()); + + var replacement = CreateReplay("Direct Strike", 900, 200); + await fixture.Importer.InsertReplays([replacement]); + + await fixture.AssertDeleted(oldUpgrades); + CollectionAssert.AreEqual(unrelatedUpgrades, await fixture.Upgrades(unrelated.ComputeHash())); + var replacementUpgrades = await fixture.Upgrades(replacement.ComputeHash()); + CollectionAssert.AreEquivalent(new[] { 201, 202, 203, 204, 301, 302, 303, 304 }, + replacementUpgrades.Select(x => x.Gameloop).ToArray()); + await fixture.AssertIntact(replays: 2, upgrades: 16); + } + + [TestMethod] + public async Task CandidateDeduplicationDeletesOnlyDiscardedReplaysUpgrades() + { + await using var fixture = await Fixture.Create(); + var keeper = CreateReplay("Keeper", 900, 200); + var duplicate = CreateReplay("Duplicate", 800, 100); + var unrelated = CreateReplay("Another match", 900, 300, dayOffset: 1); + await fixture.Importer.InsertReplays([keeper, duplicate, unrelated]); + var keeperUpgrades = await fixture.Upgrades(keeper.ComputeHash()); + var duplicateUpgrades = await fixture.Upgrades(duplicate.ComputeHash()); + var unrelatedUpgrades = await fixture.Upgrades(unrelated.ComputeHash()); + + await fixture.Importer.CheckDuplicateCandidates(); + await fixture.Importer.CheckDuplicateCandidates(); + + await fixture.AssertDeleted(duplicateUpgrades); + CollectionAssert.AreEqual(keeperUpgrades, await fixture.Upgrades(keeper.ComputeHash())); + CollectionAssert.AreEqual(unrelatedUpgrades, await fixture.Upgrades(unrelated.ComputeHash())); + await fixture.AssertIntact(replays: 2, upgrades: 16); + } + + [TestMethod] + [DataRow(800)] + [DataRow(900)] + public async Task IgnoredDuplicatePreservesStoredUpgrades(int incomingDuration) + { + await using var fixture = await Fixture.Create(); + var keeper = CreateReplay("Direct Strike", 900, 200); + await fixture.Importer.InsertReplays([keeper]); + var keeperUpgrades = await fixture.Upgrades(keeper.ComputeHash()); + + await fixture.Importer.InsertReplays([CreateReplay("Direct Strike", incomingDuration, 100)]); + + CollectionAssert.AreEqual(keeperUpgrades, await fixture.Upgrades(keeper.ComputeHash())); + await fixture.AssertIntact(replays: 1, upgrades: 8); + } + + [TestMethod] + public async Task HashTransitionDeduplicationDeletesDiscardedUpgrades() + { + await using var fixture = await Fixture.Create(); + var keeper = CreateReplay(string.Empty, 900, 200); + var duplicate = CreateReplay("Legacy title", 800, 100); + await fixture.Importer.InsertReplays([keeper, duplicate]); + var keeperUpgrades = await fixture.Upgrades(keeper.ComputeHash()); + var duplicateUpgrades = await fixture.Upgrades(duplicate.ComputeHash()); + var transition = new TransitionService(fixture.Factory, NullLogger.Instance); + + await transition.FixHashes(); + + await fixture.AssertDeleted(duplicateUpgrades); + // Hash repair can also rename the keeper's hash; its owned rows must remain unchanged. + await using var context = await fixture.Factory.CreateDbContextAsync(); + var survivor = await context.Replays.SingleAsync(); + Assert.AreEqual(900, survivor.Duration); + CollectionAssert.AreEqual(keeperUpgrades, await fixture.Upgrades(survivor.ReplayHash)); + await fixture.AssertIntact(replays: 1, upgrades: 8); + } + + [TestMethod] + public async Task FailedReplayDeletionRollsBackUpgradeDeletion() + { + await using var fixture = await Fixture.Create(); + var keeper = CreateReplay("Keeper", 900, 200); + var duplicate = CreateReplay("Duplicate", 800, 100); + await fixture.Importer.InsertReplays([keeper, duplicate]); + var duplicateUpgrades = await fixture.Upgrades(duplicate.ComputeHash()); + await using (var context = await fixture.Factory.CreateDbContextAsync()) + { + await context.Database.ExecuteSqlRawAsync(""" + CREATE TRIGGER BlockReplayDeletion BEFORE DELETE ON Replays + BEGIN SELECT RAISE(ABORT, 'Deletion blocked for rollback test'); END; + """); + } + + await Assert.ThrowsExactlyAsync(() => fixture.Importer.CheckDuplicateCandidates()); + + CollectionAssert.AreEqual(duplicateUpgrades, await fixture.Upgrades(duplicate.ComputeHash())); + await fixture.AssertIntact(replays: 2, upgrades: 16); + } + + private sealed record UpgradeSnapshot(int Id, int? ReplayPlayerId, int UpgradeId, int Gameloop); + + private sealed class Fixture(SqliteConnection connection, ServiceProvider services) : IAsyncDisposable + { + public IDbContextFactory Factory { get; } = services.GetRequiredService>(); + public IImportService Importer { get; } = services.GetRequiredService(); + + public static async Task Create() + { + var connection = new SqliteConnection("Filename=:memory:"); + await connection.OpenAsync(); + var services = new ServiceCollection().AddLogging() + .AddDbContextFactory(o => o.UseSqlite(connection, + options => options.MigrationsAssembly("dsstats.migrations.sqlite"))) + .AddSingleton(Mock.Of()) + .AddSingleton() + .BuildServiceProvider(); + var fixture = new Fixture(connection, services); + await using var context = await fixture.Factory.CreateDbContextAsync(); + await context.Database.MigrateAsync(); + return fixture; + } + + public async Task Upgrades(string replayHash) + { + await using var context = await Factory.CreateDbContextAsync(); + var upgrades = await context.ReplayPlayers.Where(p => p.Replay!.ReplayHash == replayHash) + .SelectMany(p => p.Upgrades).OrderBy(u => u.PlayerUpgradeId) + .Select(u => new UpgradeSnapshot(u.PlayerUpgradeId, EF.Property(u, "ReplayPlayerId"), u.UpgradeId, u.Gameloop)) + .ToArrayAsync(); + Assert.HasCount(8, upgrades); + return upgrades; + } + + public async Task AssertDeleted(UpgradeSnapshot[] deleted) + { + await using var context = await Factory.CreateDbContextAsync(); + var ids = deleted.Select(x => x.Id).ToArray(); + Assert.AreEqual(0, await context.PlayerUpgrades.CountAsync(u => ids.Contains(u.PlayerUpgradeId)), + "Discarded upgrades must be deleted, not detached from their replay players."); + } + + public async Task AssertIntact(int replays, int upgrades) + { + await using var context = await Factory.CreateDbContextAsync(); + Assert.AreEqual(replays, await context.Replays.CountAsync()); + Assert.AreEqual(replays * 4, await context.ReplayPlayers.CountAsync()); + Assert.AreEqual(upgrades, await context.PlayerUpgrades.CountAsync()); + Assert.AreEqual(0, await context.PlayerUpgrades.CountAsync(u => + !context.ReplayPlayers.Any(p => p.ReplayPlayerId == EF.Property(u, "ReplayPlayerId"))), + "Every surviving upgrade must still belong to a replay player."); + Assert.AreEqual(2, await context.Upgrades.CountAsync(), "Shared upgrade definitions must survive deduplication."); + } + + public async ValueTask DisposeAsync() + { + await services.DisposeAsync(); + await connection.DisposeAsync(); + } + } + + private static ReplayDto CreateReplay(string title, int duration, int upgradeGameloop, int dayOffset = 0) => new() + { + Title = title, + Version = "5.0.14", + GameMode = GameMode.Standard, + RegionId = 1, + Gametime = new DateTime(2026, 5, 23, 12, 0, 0, DateTimeKind.Utc).AddDays(dayOffset), + Duration = duration, + WinnerTeam = 1, + Players = Enumerable.Range(1, 4).Select(pos => new ReplayPlayerDto + { + Name = $"Player{pos}", + Race = Commander.Terran, + SelectedRace = Commander.Terran, + GamePos = pos, + TeamId = pos <= 2 ? 1 : 2, + Result = pos <= 2 ? PlayerResult.Win : PlayerResult.Los, + Duration = duration, + Player = new() { Name = $"Player{pos}", ToonId = new() { Region = 1, Realm = 1, Id = pos } }, + Upgrades = + [ + new() { Name = "TerranInfantryWeaponsLevel1", Gameloop = upgradeGameloop + pos }, + new() { Name = "TerranInfantryArmorsLevel1", Gameloop = upgradeGameloop + pos + 100 } + ] + }).ToList() + }; +} From 092d97862409036fdef53bee1bdf64e85b0897b5 Mon Sep 17 00:00:00 2001 From: ipax77 Date: Sat, 7 Nov 2026 09:10:37 +0100 Subject: [PATCH 3/5] bump server version to 11 --- Directory.Build.props | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Directory.Build.props b/Directory.Build.props index 6f1b404c9..2736eb76e 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -8,7 +8,7 @@ 8 5 7 - 10 + 11 $(DsstatsVersionMajor).$(DsstatsParserLine) $(DsstatsVersionBase).$(DsstatsParserPatch) From c4ee4f4e89000b10447728e6279fd4fc71f1dedc Mon Sep 17 00:00:00 2001 From: ipax77 Date: Sat, 7 Nov 2026 09:12:41 +0100 Subject: [PATCH 4/5] cu --- Directory.Build.props | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Directory.Build.props b/Directory.Build.props index 2736eb76e..81903e5dd 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -5,7 +5,7 @@ 1 0 - 8 + 9 5 7 11 From 28fea1cf28a0c782487e7f9eaa2b9874e2b9d5a2 Mon Sep 17 00:00:00 2001 From: ipax77 Date: Sat, 7 Nov 2026 09:17:18 +0100 Subject: [PATCH 5/5] cu --- Directory.Build.props | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Directory.Build.props b/Directory.Build.props index 81903e5dd..9f7d3707b 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -6,8 +6,8 @@ 0 9 - 5 - 7 + 6 + 8 11 $(DsstatsVersionMajor).$(DsstatsParserLine)