Add task scores processor

.gitignore

@@ -129,6 +129,7 @@ Data.Tests.*
 
 # Temporary files
 *.tmp
+*.csproj.lscache
 
 # Logs
 */logs/*

Sunrise.API/Controllers/ScoreController.cs

@@ -37,7 +37,7 @@ public async Task<IActionResult> GetScore([Range(1, int.MaxValue)] int id, Cance
             {
                 QueryModifier = query => query.Cast<Score>().IncludeUser()
             },
-            ct);
+            ct: ct);
 
         if (score == null)
             return Problem(ApiErrorResponse.Detail.ScoreNotFound, statusCode: StatusCodes.Status404NotFound);
@@ -58,10 +58,12 @@ public async Task<IActionResult> GetScoreReplay([Range(1, int.MaxValue)] int id,
     {
         var session = HttpContext.GetCurrentSession();
 
-        var score = await database.Scores.GetScore(id, new QueryOptions(true)
-        {
-            QueryModifier = query => query.Cast<Score>().IncludeUser()
-        }, ct);
+        var score = await database.Scores.GetScore(id,
+            new QueryOptions(true)
+            {
+                QueryModifier = query => query.Cast<Score>().IncludeUser()
+            },
+            ct: ct);
 
         if (score == null)
             return Problem(ApiErrorResponse.Detail.ScoreNotFound, statusCode: StatusCodes.Status404NotFound);

Sunrise.API/Serializable/Response/UserResponse.cs

@@ -20,6 +20,9 @@ public UserResponse()
 
     public UserResponse(SessionRepository sessionRepository, User user)
     {
+        if (user == null)
+            throw new ArgumentNullException(nameof(user), "User must be loaded before constructing UserResponse.");
+
         var session = sessionRepository.GetSession(userId: user.Id);
 
         Id = user.Id;

Sunrise.API/Services/UserService.cs

@@ -150,7 +150,7 @@ public async Task<IActionResult> SetUserAvatar(
 
         if (!isSet || error != null)
         {
-            SunriseMetrics.RequestReturnedErrorCounterInc(RequestType.AvatarUpload, null, error);
+            SunriseMetrics.RequestReturnedErrorCounterInc(RequestType.AvatarUpload, eventAction.TargetUserId, error);
             return new ObjectResult(new ProblemDetails
             {
                 Title = ApiErrorResponse.Title.UnableToChangeAvatar,
@@ -185,7 +185,7 @@ public async Task<IActionResult> SetUserBanner(
 
         if (!isSet || error != null)
         {
-            SunriseMetrics.RequestReturnedErrorCounterInc(RequestType.BannerUpload, null, error);
+            SunriseMetrics.RequestReturnedErrorCounterInc(RequestType.BannerUpload, eventAction.TargetUserId, error);
             return new ObjectResult(new ProblemDetails
             {
                 Title = ApiErrorResponse.Title.UnableToChangeBanner,
@@ -626,4 +626,4 @@ public static List<UserBadge> GetUserBadges(User user)
 
         return badges;
     }
-}
+}

Sunrise.Processing.Tests/DatabaseFixture.cs

@@ -0,0 +1,12 @@
+using Xunit;
+
+namespace Sunrise.Processing.Tests;
+
+public class IntegrationDatabaseFixture : Sunrise.Tests.IntegrationDatabaseFixture
+{
+}
+
+[CollectionDefinition("Integration tests collection")]
+public class DatabaseTestCollection : ICollectionFixture<IntegrationDatabaseFixture>
+{
+}

Sunrise.Processing.Tests/Scores/Handlers/ScoreDeletionHandlerTests.cs

@@ -0,0 +1,96 @@
+using Microsoft.Extensions.DependencyInjection;
+using Sunrise.Processing.Scores.Handlers;
+using Sunrise.Shared.Database.Models.Scores;
+using Sunrise.Shared.Enums.Scores;
+using Sunrise.Tests.Abstracts;
+using Sunrise.Tests.Extensions;
+using Sunrise.Tests.Services.Mock;
+using Xunit;
+using SubmissionStatus = Sunrise.Shared.Enums.Scores.SubmissionStatus;
+
+namespace Sunrise.Processing.Tests.Scores.Handlers;
+
+[Collection("Integration tests collection")]
+public class ScoreDeletionHandlerTests(IntegrationDatabaseFixture fixture) : DatabaseTest(fixture)
+{
+    private readonly MockService _mocker = new();
+
+    [Fact]
+    public async Task TestPrepareAsyncWithMissingScoreReturnsUnexpectedError()
+    {
+        // Arrange
+        var handler = (ScoreDeletionHandler)Scope.ServiceProvider
+            .GetRequiredKeyedService<IScoreHandler>(ScoreTaskType.Delete);
+
+        // Act
+        var result = await handler.PrepareAsync(new ScoreProcessingTask
+            {
+                TaskType = ScoreTaskType.Delete,
+                ScoreId = 999_999
+            },
+            CancellationToken.None);
+
+        // Assert
+        Assert.True(result.IsFailure);
+        Assert.Equal(ScoreProcessingErrorCode.Unexpected, result.Error.Code);
+    }
+
+    [Fact]
+    public async Task TestPrepareAsyncWithAlreadyDeletedScoreReturnsFailure()
+    {
+        // Arrange
+        var user = await CreateTestUser();
+        var score = _mocker.Score.GetBestScoreableRandomScore();
+        score.EnrichWithUserData(user);
+
+        score.SubmissionStatus = SubmissionStatus.Deleted;
+
+        score = await CreateTestScore(score);
+
+        var handler = (ScoreDeletionHandler)Scope.ServiceProvider
+            .GetRequiredKeyedService<IScoreHandler>(ScoreTaskType.Delete);
+
+        // Act
+        var result = await handler.PrepareAsync(new ScoreProcessingTask
+            {
+                TaskType = ScoreTaskType.Delete,
+                ScoreId = score.Id
+            },
+            CancellationToken.None);
+
+        // Assert
+        Assert.True(result.IsFailure);
+        Assert.Equal(ScoreProcessingErrorCode.InvalidScoreState, result.Error.Code);
+    }
+
+    [Fact]
+    public async Task TestPrepareAsyncWithValidScoreReturnsDeletionContext()
+    {
+        // Arrange
+        var user = await CreateTestUser();
+        var score = _mocker.Score.GetBestScoreableRandomScore();
+        score.EnrichWithUserData(user);
+
+        score.SubmissionStatus = SubmissionStatus.Submitted;
+
+        score = await CreateTestScore(score);
+
+        var handler = (ScoreDeletionHandler)Scope.ServiceProvider
+            .GetRequiredKeyedService<IScoreHandler>(ScoreTaskType.Delete);
+
+        // Act
+        var result = await handler.PrepareAsync(new ScoreProcessingTask
+            {
+                TaskType = ScoreTaskType.Delete,
+                ScoreId = score.Id
+            },
+            CancellationToken.None);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+        Assert.Equal(score.Id, result.Value.Score.Id);
+        Assert.Equal(user.Id, result.Value.User.Id);
+        Assert.Equal(user.Id, result.Value.UserStats.UserId);
+        Assert.Equal(user.Id, result.Value.UserGrades.UserId);
+    }
+}

Sunrise.Processing.Tests/Scores/Handlers/ScoreRecalculationHandlerTests.cs

@@ -0,0 +1,187 @@
+using Microsoft.Extensions.DependencyInjection;
+using Sunrise.Processing.Scores.Handlers;
+using Sunrise.Shared.Database.Models.Scores;
+using Sunrise.Shared.Enums.Scores;
+using Sunrise.Tests.Abstracts;
+using Sunrise.Tests.Extensions;
+using Sunrise.Tests.Services.Mock;
+using Xunit;
+
+namespace Sunrise.Processing.Tests.Scores.Handlers;
+
+[Collection("Integration tests collection")]
+public class ScoreRecalculationHandlerTests(IntegrationDatabaseFixture fixture) : DatabaseTest(fixture)
+{
+    private readonly MockService _mocker = new();
+
+    [Fact]
+    public async Task TestPrepareAsyncWithMissingScoreReturnsUnexpectedError()
+    {
+        // Arrange
+        var handler = (ScoreRecalculationHandler)Scope.ServiceProvider
+            .GetRequiredKeyedService<IScoreHandler>(ScoreTaskType.Recalculation);
+
+        // Act
+        var result = await handler.PrepareAsync(new ScoreProcessingTask
+            {
+                TaskType = ScoreTaskType.Recalculation,
+                ScoreId = 999_999
+            },
+            CancellationToken.None);
+
+        // Assert
+        Assert.True(result.IsFailure);
+        Assert.Equal(ScoreProcessingErrorCode.Unexpected, result.Error.Code);
+        Assert.Equal(ScoreProcessingDisposition.Permanent, result.Error.Disposition);
+    }
+
+    [Fact]
+    public async Task TestPrepareAsyncWithDeletedScoreReturnsUnexpectedError()
+    {
+        // Arrange
+        var user = await CreateTestUser();
+        var score = _mocker.Score.GetBestScoreableRandomScore();
+        score.EnrichWithUserData(user);
+
+        score.SubmissionStatus = SubmissionStatus.Deleted;
+
+        score = await CreateTestScore(score);
+
+        var handler = (ScoreRecalculationHandler)Scope.ServiceProvider
+            .GetRequiredKeyedService<IScoreHandler>(ScoreTaskType.Recalculation);
+
+        // Act
+        var result = await handler.PrepareAsync(new ScoreProcessingTask
+            {
+                TaskType = ScoreTaskType.Recalculation,
+                ScoreId = score.Id
+            },
+            CancellationToken.None);
+
+        // Assert
+        Assert.True(result.IsFailure);
+        Assert.Equal(ScoreProcessingErrorCode.InvalidScoreState, result.Error.Code);
+        Assert.Equal(ScoreProcessingDisposition.Permanent, result.Error.Disposition);
+    }
+
+    [Fact]
+    public async Task TestPrepareAsyncWithServerErrorResponseForBeatmapReturnsBeatmapNotFoundRetryable()
+    {
+        // Arrange
+        var user = await CreateTestUser();
+        var score = _mocker.Score.GetBestScoreableRandomScore();
+        score.EnrichWithUserData(user);
+        score = await CreateTestScore(score);
+
+        App.MockHttpClient?.MockBeatmapSetByHashInternalServerError();
+
+        var handler = (ScoreRecalculationHandler)Scope.ServiceProvider
+            .GetRequiredKeyedService<IScoreHandler>(ScoreTaskType.Recalculation);
+
+        // Act
+        var result = await handler.PrepareAsync(new ScoreProcessingTask
+            {
+                TaskType = ScoreTaskType.Recalculation,
+                ScoreId = score.Id
+            },
+            CancellationToken.None);
+
+        // Assert
+        Assert.True(result.IsFailure);
+        Assert.Equal(ScoreProcessingErrorCode.BeatmapNotFound, result.Error.Code);
+        Assert.Equal(ScoreProcessingDisposition.Retryable, result.Error.Disposition);
+    }
+
+    [Fact]
+    public async Task TestPrepareAsyncWithMissingBeatmapReturnsBeatmapNotFoundPermanent()
+    {
+        // Arrange
+        var user = await CreateTestUser();
+        var score = _mocker.Score.GetBestScoreableRandomScore();
+        score.EnrichWithUserData(user);
+        score = await CreateTestScore(score);
+
+        App.MockHttpClient?.MockBeatmapSetByBeatmapIdNotFound(score.BeatmapId);
+
+        var handler = (ScoreRecalculationHandler)Scope.ServiceProvider
+            .GetRequiredKeyedService<IScoreHandler>(ScoreTaskType.Recalculation);
+
+        // Act
+        var result = await handler.PrepareAsync(new ScoreProcessingTask
+            {
+                TaskType = ScoreTaskType.Recalculation,
+                ScoreId = score.Id
+            },
+            CancellationToken.None);
+
+        // Assert
+        Assert.True(result.IsFailure);
+        Assert.Equal(ScoreProcessingErrorCode.BeatmapNotFound, result.Error.Code);
+        Assert.Equal(ScoreProcessingDisposition.Permanent, result.Error.Disposition);
+    }
+
+    [Fact]
+    public async Task TestPrepareAsyncWithFailedPpCalculationReturnsPpCalculationFailed()
+    {
+        // Arrange
+        var user = await CreateTestUser();
+        var score = _mocker.Score.GetBestScoreableRandomScore();
+        score.EnrichWithUserData(user);
+        score = await CreateTestScore(score);
+
+        await _mocker.Beatmap.MockRankedBeatmapWithSetForScore(score);
+
+        var handler = (ScoreRecalculationHandler)Scope.ServiceProvider
+            .GetRequiredKeyedService<IScoreHandler>(ScoreTaskType.Recalculation);
+
+        // Act
+        var result = await handler.PrepareAsync(new ScoreProcessingTask
+            {
+                TaskType = ScoreTaskType.Recalculation,
+                ScoreId = score.Id
+            },
+            CancellationToken.None);
+
+        // Assert
+        Assert.True(result.IsFailure);
+        Assert.Equal(ScoreProcessingErrorCode.PpCalculationFailed, result.Error.Code);
+        Assert.Equal(ScoreProcessingDisposition.Retryable, result.Error.Disposition);
+    }
+
+    [Fact]
+    public async Task TestPrepareAsyncWithExistingScoreReturnsContextWithRecalculatedPerformance()
+    {
+        // Arrange
+        var user = await CreateTestUser();
+        var score = _mocker.Score.GetBestScoreableRandomScore();
+        score.EnrichWithUserData(user);
+
+        score.PerformancePoints = 123;
+
+        score = await CreateTestScore(score);
+
+        var (_, beatmap) = await _mocker.Beatmap.MockRankedBeatmapWithSetForScore(score);
+        App.MockHttpClient?.MockPerformanceCalculation(performancePoints: 321);
+
+        var handler = (ScoreRecalculationHandler)Scope.ServiceProvider
+            .GetRequiredKeyedService<IScoreHandler>(ScoreTaskType.Recalculation);
+
+        // Act
+        var result = await handler.PrepareAsync(new ScoreProcessingTask
+            {
+                TaskType = ScoreTaskType.Recalculation,
+                ScoreId = score.Id
+            },
+            CancellationToken.None);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+
+        Assert.Equal(ScoreTaskType.Recalculation, result.Value.TaskType);
+        Assert.Equal(score.Id, result.Value.Score.Id);
+        Assert.Equal(321, result.Value.Score.PerformancePoints);
+
+        Assert.NotNull(result.Value.Beatmap);
+        Assert.Equal(beatmap.Checksum, result.Value.Beatmap!.Checksum);
+    }
+}