Fix protected-name pagination counts and deterministic fake ordering

Co-authored-by: frasermolyneux <34033625+frasermolyneux@users.noreply.github.com>

Author: Copilot

src/XtremeIdiots.Portal.Repository.Api.Client.Testing.Tests/FakePlayersApiTests.cs

@@ -145,6 +145,22 @@ public async Task GetProtectedNames_FiltersByGameType()
         Assert.Equal(cod4Player.PlayerId, items[0].PlayerId);
     }
 
+    [Fact]
+    public async Task GetProtectedNames_OrdersByNameBeforePagination()
+    {
+        var fake = new FakePlayersApi();
+        var player = RepositoryDtoFactory.CreatePlayer(gameType: GameType.CallOfDuty4);
+        fake.AddPlayer(player);
+        fake.AddProtectedName(RepositoryDtoFactory.CreateProtectedName(playerId: player.PlayerId, name: "Zulu"));
+        fake.AddProtectedName(RepositoryDtoFactory.CreateProtectedName(playerId: player.PlayerId, name: "Alpha"));
+
+        var result = await fake.GetProtectedNames(0, 1);
+
+        Assert.Equal(HttpStatusCode.OK, result.StatusCode);
+        var item = Assert.Single(result.Result!.Data!.Items!);
+        Assert.Equal("Alpha", item.Name);
+    }
+
     [Fact]
     public void AddPlayer_FluentChaining_Works()
     {

src/XtremeIdiots.Portal.Repository.Api.Client.Testing/Fakes/FakePlayersApi.cs

@@ -138,7 +138,11 @@ public Task<ApiResult<CollectionModel<ProtectedNameDto>>> GetProtectedNames(int
         if (gameType.HasValue)
             items = items.Where(pn => _players.TryGetValue(pn.PlayerId, out var player) && player.GameType == gameType.Value);
 
-        var paginatedItems = items.Skip(skipEntries).Take(takeEntries).ToList();
+        var paginatedItems = items
+            .OrderBy(pn => pn.Name)
+            .Skip(skipEntries)
+            .Take(takeEntries)
+            .ToList();
         var collection = new CollectionModel<ProtectedNameDto> { Items = paginatedItems };
         return Task.FromResult(new ApiResult<CollectionModel<ProtectedNameDto>>(HttpStatusCode.OK, new ApiResponse<CollectionModel<ProtectedNameDto>>(collection)));
     }

src/XtremeIdiots.Portal.Repository.Api.Tests.V1/Controllers/V1/PlayersControllerTests.cs

@@ -953,6 +953,9 @@ public async Task GetProtectedNames_WithGameTypeFilter_ReturnsOnlyMatchingGameTy
         Assert.Equal(HttpStatusCode.OK, result.StatusCode);
         var item = Assert.Single(result.Result!.Data!.Items!);
         Assert.Equal(cod4PlayerId, item.PlayerId);
+        Assert.NotNull(result.Result.Pagination);
+        Assert.Equal(2, result.Result.Pagination!.TotalCount);
+        Assert.Equal(1, result.Result.Pagination.FilteredCount);
     }
 
     #endregion

src/XtremeIdiots.Portal.Repository.Api.V1/Controllers/V1/PlayersController.cs

@@ -1064,12 +1064,15 @@ public async Task<IActionResult> GetProtectedNames(
     /// <returns>An API result containing a paginated collection of protected names.</returns>
     async Task<ApiResult<CollectionModel<ProtectedNameDto>>> IPlayersApi.GetProtectedNames(int skipEntries, int takeEntries, GameType? gameType)
     {
-        IQueryable<ProtectedName> query = context.ProtectedNames.AsNoTracking();
+        IQueryable<ProtectedName> totalCountQuery = context.ProtectedNames.AsNoTracking();
+        var totalCount = await totalCountQuery.CountAsync().ConfigureAwait(false);
+
+        IQueryable<ProtectedName> filteredQuery = totalCountQuery;
 
         if (gameType.HasValue)
         {
             var gameTypeValue = (int)gameType.Value;
-            query = query
+            filteredQuery = filteredQuery
                 .Where(pn => pn.PlayerId.HasValue)
                 .Join(
                     context.Players.AsNoTracking().Where(p => p.GameType == gameTypeValue),
@@ -1078,13 +1081,11 @@ async Task<ApiResult<CollectionModel<ProtectedNameDto>>> IPlayersApi.GetProtecte
                     (pn, _) => pn);
         }
 
-        query = query
-            .Include(pn => pn.Player)
-            .Include(pn => pn.CreatedByUserProfile);
-
-        var totalCount = await query.CountAsync().ConfigureAwait(false);
+        var filteredCount = await filteredQuery.CountAsync().ConfigureAwait(false);
 
-        var paginatedQuery = query
+        var paginatedQuery = filteredQuery
+            .Include(pn => pn.Player)
+            .Include(pn => pn.CreatedByUserProfile)
             .OrderBy(pn => pn.Name)
             .Skip(skipEntries)
             .Take(takeEntries);
@@ -1097,7 +1098,7 @@ async Task<ApiResult<CollectionModel<ProtectedNameDto>>> IPlayersApi.GetProtecte
 
         return new ApiResponse<CollectionModel<ProtectedNameDto>>(data)
         {
-            Pagination = new ApiPagination(totalCount, totalCount, skipEntries, takeEntries)
+            Pagination = new ApiPagination(totalCount, filteredCount, skipEntries, takeEntries)
         }.ToApiResult();
     }
 
@@ -1232,11 +1233,11 @@ async Task<ApiResult> IPlayersApi.CreateProtectedName(CreateProtectedNameDto cre
                 && pn.Name.ToLower() == createProtectedNameDto.Name.ToLower()
                 && pn.PlayerId.HasValue)
             .Join(
-                context.Players.AsNoTracking(),
+                context.Players.AsNoTracking().Where(p => p.GameType == playerGameType.Value),
                 pn => pn.PlayerId!.Value,
                 p => p.PlayerId,
-                (_, p) => p.GameType)
-            .AnyAsync(gt => gt == playerGameType.Value)
+                (pn, _) => pn)
+            .AnyAsync()
             .ConfigureAwait(false);
 
         if (nameExistsInGameType)