Actually test upload rate-limits for levels/photos/playlists

Author: Toastbrot236

RefreshTests.GameServer/Tests/Levels/PublishEndpointsTests.cs

@@ -14,6 +14,7 @@
 using Refresh.Interfaces.Game.Types.Levels;
 using System.Security.Cryptography;
 using System.Text;
+using System.Net;
 
 namespace RefreshTests.GameServer.Tests.Levels;
 
@@ -496,113 +497,91 @@ public void CantUnpublishSomeoneElsesLevel()
     }
 
     [Test]
-    [TestCase(2, 2)]
-    public void CantPublishAfterExceedingTimedLevelLimit(int levelQuota, int uploadAttemptsAfterExceeding)
+    [TestCase(4, 4, 1)]
+    public void LevelUploadsGetRateLimitedTemporarily(int levelQuota, int uploadAttemptsAfterExceeding, int timeSpanHours)
     {
         using TestContext context = this.GetServer();
         GameUser user = context.CreateUser("thepublisher");
 
         // Prepare config
         GameServerConfig config = context.Server.Value.GameServerConfig;
-        EntityUploadRateLimitProperties timedLevelLimit = new()
+        EntityUploadRateLimitProperties uploadConfig = new()
         {
             Enabled = true,
             UploadQuota = levelQuota,
-            TimeSpanHours = 1,
+            TimeSpanHours = timeSpanHours,
         };
-        config.NormalUserPermissions.LevelUploadRateLimit = timedLevelLimit;
+        config.NormalUserPermissions.LevelUploadRateLimit = uploadConfig;
 
         using HttpClient client = context.GetAuthenticatedClient(TokenType.Game, user);
+        int publishAttempts = 0;
 
-        // Upload level asset
-        HttpResponseMessage assetUploadMessage = client.PostAsync($"/lbp/upload/{TEST_ASSET_HASH}", new ReadOnlyMemoryContent("LVLb"u8.ToArray())).Result;
-        Assert.That(assetUploadMessage.StatusCode, Is.EqualTo(OK));
+        // Not blocked yet
+        Assert.That(context.Database.GetUploadRateLimit(user, GameDatabaseEntity.Level), Is.Null);
+        Assert.That(context.Database.GetRemainingTimeIfUploadRateLimitReached(user, GameDatabaseEntity.Level, uploadConfig.UploadQuota), Is.Null);
 
-        // Fill up quota
-        SpamSuccessfulUploads(timedLevelLimit.UploadQuota, client, 0);
-        
-        // Try to upload more levels after exceeding quota
-        for (int i = 0; i < uploadAttemptsAfterExceeding; i++)
-        {
-            GameLevelRequest level = PrepareLevelPublishRequest(client, i + timedLevelLimit.UploadQuota);
-
-            HttpResponseMessage message = client.PostAsync("/lbp/startPublish", new StringContent(level.AsXML())).Result;
-            Assert.That(message.StatusCode, Is.EqualTo(Unauthorized));
-            message = client.PostAsync("/lbp/publish", new StringContent(level.AsXML())).Result;
-            Assert.That(message.StatusCode, Is.EqualTo(Unauthorized));
-        }
-
-        // Check amount of levels
-        DatabaseList<GameLevel> levelsByUser = context.Database.GetLevelsByUser(user, 1000, 0, new(TokenGame.LittleBigPlanet3), user);
-        Assert.That(levelsByUser.TotalItems, Is.EqualTo(timedLevelLimit.UploadQuota));
-
-        // Ensure there were error notifications sent for each blocked request to both /startPublish and /publish
-        DatabaseList<GameNotification> newNotifications = context.Database.GetNotificationsByUser(user, 1000, 0);
-        Assert.That(newNotifications.TotalItems, Is.EqualTo(uploadAttemptsAfterExceeding * 2));
-    }
+        // Fill up half of quota
+        publishAttempts += SpamPublishUniqueLevels(uploadConfig.UploadQuota / 2, client, publishAttempts);
+        context.Database.Refresh();
 
-    [Test]
-    [TestCase(2, 2)]
-    public void ResetTimedLevelLimitAfterExpiry(int levelQuota, int uploadAttemptsAfterExceeding)
-    {
-        using TestContext context = this.GetServer();
-        GameUser user = context.CreateUser("thepublisher");
+        // There is rate-limit data in DB, but the rate-limit hasn't been triggered yet
+        EntityUploadRateLimit? uploadLimit = context.Database.GetUploadRateLimit(user, GameDatabaseEntity.Level);
+        Assert.That(uploadLimit, Is.Not.Null);
+        Assert.That(uploadLimit!.UploadCount, Is.EqualTo(uploadConfig.UploadQuota / 2));
+        Assert.That(context.Database.GetRemainingTimeIfUploadRateLimitReached(user, GameDatabaseEntity.Level, uploadConfig.UploadQuota), Is.Null);
+        
+        // Try to upload more levels to reach quota
+        publishAttempts += SpamPublishUniqueLevels(uploadConfig.UploadQuota / 2, client, publishAttempts);
+        context.Database.Refresh();
 
-        // Prepare config
-        GameServerConfig config = context.Server.Value.GameServerConfig;
-        EntityUploadRateLimitProperties timedLevelLimit = new()
-        {
-            Enabled = true,
-            UploadQuota = levelQuota,
-            // Having this be 0 causes the server to always set the expiry date to now, making the expiry date be not null but always expired,
-            // causing both /startPublish and /publish to always reset the limit after setting it in a previous /publish request, and allowing publish requests
-            TimeSpanHours = 0,
-        };
-        config.NormalUserPermissions.LevelUploadRateLimit = timedLevelLimit;
+        // Ensure there were no notifications sent
+        Assert.That(context.Database.GetNotificationCountByUser(user), Is.Zero);
 
-        using HttpClient client = context.GetAuthenticatedClient(TokenType.Game, user);
+        // There is rate-limit data in DB, and the rate-limit has been triggered
+        uploadLimit = context.Database.GetUploadRateLimit(user, GameDatabaseEntity.Level);
+        Assert.That(uploadLimit, Is.Not.Null);
+        Assert.That(uploadLimit!.UploadCount, Is.EqualTo(uploadConfig.UploadQuota));
+        Assert.That(context.Database.GetRemainingTimeIfUploadRateLimitReached(user, GameDatabaseEntity.Level, uploadConfig.UploadQuota), Is.Not.Null);
 
-        // Upload level asset
-        HttpResponseMessage message = client.PostAsync($"/lbp/upload/{TEST_ASSET_HASH}", new ReadOnlyMemoryContent("LVLb"u8.ToArray())).Result;
-        Assert.That(message.StatusCode, Is.EqualTo(OK));
+        // levels are blocked
+        publishAttempts += SpamPublishUniqueLevels(uploadAttemptsAfterExceeding, client, publishAttempts, Unauthorized);
+        context.Database.Refresh();
 
-        // Fill up quota
-        SpamSuccessfulUploads(timedLevelLimit.UploadQuota, client, 0);
-        
-        // Try to upload more levels after exceeding quota
-        SpamSuccessfulUploads(uploadAttemptsAfterExceeding, client, timedLevelLimit.UploadQuota);
+        // Check amount of levels, and ensure there were notifications sent for every failed level
+        Assert.That(context.Database.GetTotalLevelsByUser(user), Is.EqualTo(uploadConfig.UploadQuota));
+        Assert.That(context.Database.GetNotificationCountByUser(user), Is.EqualTo(uploadAttemptsAfterExceeding * 2));
 
-        // Check amount of levels
-        DatabaseList<GameLevel> levelsByUser = context.Database.GetLevelsByUser(user, 1000, 0, new(TokenGame.LittleBigPlanet3), user);
-        Assert.That(levelsByUser.TotalItems, Is.EqualTo(timedLevelLimit.UploadQuota + uploadAttemptsAfterExceeding));
+        // Expire limit naturally by trying to publish again later
+        context.Time.TimestampMilliseconds = 1000 * 60 * 60 * timeSpanHours + 10;
+        publishAttempts += SpamPublishUniqueLevels(uploadAttemptsAfterExceeding, client, publishAttempts);
+        context.Database.Refresh();
 
-        // Ensure there were no notifications sent
-        DatabaseList<GameNotification> newNotifications = context.Database.GetNotificationsByUser(user, 1000, 0);
-        Assert.That(newNotifications.TotalItems, Is.EqualTo(0));
+        // there are more levels now, and no new notifications
+        Assert.That(context.Database.GetTotalLevelsByUser(user), Is.EqualTo(uploadConfig.UploadQuota * 2));
+        Assert.That(context.Database.GetNotificationCountByUser(user), Is.EqualTo(uploadAttemptsAfterExceeding * 2));
     }
 
-    private void SpamSuccessfulUploads(int uploads, HttpClient client, int startIndex)
+    private int SpamPublishUniqueLevels(int uploads, HttpClient client, int startIndex, HttpStatusCode expectedStatus = OK)
     {
         for (int i = 0; i < uploads; i++)
         {
             // Upload level
-            GameLevelRequest level = PrepareLevelPublishRequest(client, startIndex + i);
+            GameLevelRequest level = PrepareUniqueLevelPublishRequest(client, startIndex + i);
 
             HttpResponseMessage message = client.PostAsync("/lbp/startPublish", new StringContent(level.AsXML())).Result;
-            Assert.That(message.StatusCode, Is.EqualTo(OK));
+            Assert.That(message.StatusCode, Is.EqualTo(expectedStatus));
             message = client.PostAsync("/lbp/publish", new StringContent(level.AsXML())).Result;
-            Assert.That(message.StatusCode, Is.EqualTo(OK));
+            Assert.That(message.StatusCode, Is.EqualTo(expectedStatus));
         }
+
+        return uploads;
     }
 
-    private GameLevelRequest PrepareLevelPublishRequest(HttpClient client, int uniqueValue)
+    private GameLevelRequest PrepareUniqueLevelPublishRequest(HttpClient client, int uniqueValue)
     {
         // upload root asset
         ReadOnlySpan<byte> rootResource = new(Encoding.ASCII.GetBytes($"LVLb {uniqueValue}"));
-
-        string rootHash = BitConverter.ToString(SHA1.HashData(rootResource))
-            .Replace("-", "")
-            .ToLower();
+        string rootHash = BitConverter.ToString(SHA1.HashData(rootResource)).Replace("-", "").ToLower();
 
         HttpResponseMessage message = client.PostAsync($"/lbp/upload/{rootHash}", new ReadOnlyMemoryContent(rootResource.ToArray())).Result;
         Assert.That(message.StatusCode, Is.EqualTo(OK));

RefreshTests.GameServer/Tests/Photos/PhotoEndpointsTests.cs

@@ -8,6 +8,10 @@
 using Refresh.Interfaces.Game.Types.Lists;
 using Refresh.Database.Helpers;
 using System.Security.Cryptography;
+using Refresh.Core.Configuration;
+using Refresh.Database.Models;
+using System.Text;
+using System.Net;
 
 namespace RefreshTests.GameServer.Tests.Photos;
 
@@ -508,4 +512,115 @@ public void CannotUploadPhotoIfDuplicatePlan()
         Assert.That(message.StatusCode, Is.EqualTo(BadRequest));
         Assert.That(context.Database.GetNotificationCountByUser(user), Is.EqualTo(1));
     }
+
+    [Test]
+    [TestCase(4, 4, 1)]
+    public void PhotoUploadsGetRateLimitedTemporarily(int photoQuota, int uploadAttemptsAfterExceeding, int timeSpanHours)
+    {
+        using TestContext context = this.GetServer();
+        GameUser user = context.CreateUser("thepublisher");
+        GameLevel level = context.CreateLevel(user);
+
+        // Prepare config
+        GameServerConfig config = context.Server.Value.GameServerConfig;
+        EntityUploadRateLimitProperties uploadConfig = new()
+        {
+            Enabled = true,
+            UploadQuota = photoQuota,
+            TimeSpanHours = timeSpanHours,
+        };
+        config.NormalUserPermissions.PhotoUploadRateLimit = uploadConfig;
+
+        using HttpClient client = context.GetAuthenticatedClient(TokenType.Game, user);
+        int publishAttempts = 0;
+
+        // Not blocked yet
+        Assert.That(context.Database.GetUploadRateLimit(user, GameDatabaseEntity.Photo), Is.Null);
+        Assert.That(context.Database.GetRemainingTimeIfUploadRateLimitReached(user, GameDatabaseEntity.Photo, uploadConfig.UploadQuota), Is.Null);
+
+        // Fill up half of quota
+        publishAttempts += SpamUploadUniquePhotos(uploadConfig.UploadQuota / 2, client, publishAttempts, level);
+        context.Database.Refresh();
+
+        // There is rate-limit data in DB, but the rate-limit hasn't been triggered yet
+        EntityUploadRateLimit? uploadLimit = context.Database.GetUploadRateLimit(user, GameDatabaseEntity.Photo);
+        Assert.That(uploadLimit, Is.Not.Null);
+        Assert.That(uploadLimit!.UploadCount, Is.EqualTo(uploadConfig.UploadQuota / 2));
+        Assert.That(context.Database.GetRemainingTimeIfUploadRateLimitReached(user, GameDatabaseEntity.Photo, uploadConfig.UploadQuota), Is.Null);
+        
+        // Try to upload more photos to reach quota
+        publishAttempts += SpamUploadUniquePhotos(uploadConfig.UploadQuota / 2, client, publishAttempts, level);
+        context.Database.Refresh();
+
+        // Ensure there were no notifications sent
+        Assert.That(context.Database.GetNotificationCountByUser(user), Is.Zero);
+
+        // There is rate-limit data in DB, and the rate-limit has been triggered
+        uploadLimit = context.Database.GetUploadRateLimit(user, GameDatabaseEntity.Photo);
+        Assert.That(uploadLimit, Is.Not.Null);
+        Assert.That(uploadLimit!.UploadCount, Is.EqualTo(uploadConfig.UploadQuota));
+        Assert.That(context.Database.GetRemainingTimeIfUploadRateLimitReached(user, GameDatabaseEntity.Photo, uploadConfig.UploadQuota), Is.Not.Null);
+
+        // photos are blocked
+        publishAttempts += SpamUploadUniquePhotos(uploadAttemptsAfterExceeding, client, publishAttempts, level, Unauthorized);
+        context.Database.Refresh();
+
+        // Check amount of photos, and ensure there were notifications sent for every failed photo
+        Assert.That(context.Database.GetTotalPhotosByUser(user), Is.EqualTo(uploadConfig.UploadQuota));
+        Assert.That(context.Database.GetNotificationCountByUser(user), Is.EqualTo(uploadAttemptsAfterExceeding));
+
+        // Expire limit naturally by trying to publish again later
+        context.Time.TimestampMilliseconds = 1000 * 60 * 60 * timeSpanHours + 10;
+        publishAttempts += SpamUploadUniquePhotos(uploadAttemptsAfterExceeding, client, publishAttempts, level);
+        context.Database.Refresh();
+
+        // there are more levels now, and no new notifications
+        Assert.That(context.Database.GetTotalPhotosByUser(user), Is.EqualTo(uploadConfig.UploadQuota * 2));
+        Assert.That(context.Database.GetNotificationCountByUser(user), Is.EqualTo(uploadAttemptsAfterExceeding));
+    }
+
+    private int SpamUploadUniquePhotos(int uploads, HttpClient client, int startIndex, GameLevel level, HttpStatusCode expectedStatus = OK)
+    {
+        for (int i = 0; i < uploads; i++)
+        {
+            // Upload level
+            SerializedPhoto photo = PrepareUniquePhotoUploadRequest(client, level, startIndex + i);
+
+            HttpResponseMessage message = client.PostAsync($"/lbp/uploadPhoto", new StringContent(photo.AsXML())).Result;
+            Assert.That(message.StatusCode, Is.EqualTo(expectedStatus));
+        }
+
+        return uploads;
+    }
+
+    private SerializedPhoto PrepareUniquePhotoUploadRequest(HttpClient client, GameLevel level, int uniqueValue)
+    {
+        // upload """photo"""
+        ReadOnlySpan<byte> imageResource = new(Encoding.ASCII.GetBytes($"TEX  {uniqueValue}"));
+        string imageHash = BitConverter.ToString(SHA1.HashData(imageResource)).Replace("-", "").ToLower();
+        HttpResponseMessage message = client.PostAsync($"/lbp/upload/{imageHash}", new ReadOnlyMemoryContent(imageResource.ToArray())).Result;
+        Assert.That(message.StatusCode, Is.EqualTo(OK));
+
+        // upload """plan"""
+        ReadOnlySpan<byte> planResource = new(Encoding.ASCII.GetBytes($"PLNb {uniqueValue}"));
+        string planHash = BitConverter.ToString(SHA1.HashData(planResource)).Replace("-", "").ToLower();
+        message = client.PostAsync($"/lbp/upload/{planHash}", new ReadOnlyMemoryContent(planResource.ToArray())).Result;
+        Assert.That(message.StatusCode, Is.EqualTo(OK));
+
+        // prepare request body
+        return new()
+        {
+            Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
+            SmallHash = imageHash,
+            MediumHash = imageHash,
+            LargeHash = imageHash,
+            PlanHash = planHash,
+            Level = new SerializedPhotoLevel
+            {
+                LevelId = level.LevelId,
+                Title = level.Title,
+                Type = "user",
+            },
+        };
+    }
 }