Backport pull request #18268 from jellyfin/release-12.z

Fix off-by-one in the optimistic locking retry backoff

Original-merge: 765e09e333

Merged-by: crobibero <cody@robibe.ro>

Backported-by: Cody Robibero <cody@robibe.ro>

tests/Jellyfin.Server.Implementations.Tests/Locking/OptimisticLockBehaviorTests.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Jellyfin.Database.Implementations.Locking;
+using Microsoft.Data.Sqlite;
+using Microsoft.Extensions.Logging.Abstractions;
+using Polly.Utilities;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Locking;
+
+/// <summary>
+/// The retries of <see cref="OptimisticLockBehavior"/> when the database stays locked. Polly's clock records the
+/// waits instead of sleeping through them, and the save hooks never use the context, so none is created.
+/// </summary>
+public sealed class OptimisticLockBehaviorTests : IDisposable
+{
+    private static readonly TimeSpan[] _sleepDurations =
+    [
+        TimeSpan.FromMilliseconds(50),
+        TimeSpan.FromMilliseconds(50),
+        TimeSpan.FromMilliseconds(50),
+        TimeSpan.FromMilliseconds(50),
+        TimeSpan.FromMilliseconds(250),
+        TimeSpan.FromMilliseconds(250),
+        TimeSpan.FromMilliseconds(250),
+        TimeSpan.FromMilliseconds(150),
+        TimeSpan.FromMilliseconds(150),
+        TimeSpan.FromMilliseconds(150),
+        TimeSpan.FromMilliseconds(500),
+        TimeSpan.FromMilliseconds(150),
+        TimeSpan.FromMilliseconds(500),
+        TimeSpan.FromMilliseconds(150),
+        TimeSpan.FromSeconds(3)
+    ];
+
+    private readonly List<TimeSpan> _waits = [];
+    private readonly OptimisticLockBehavior _behavior = new(NullLogger<OptimisticLockBehavior>.Instance);
+
+    public OptimisticLockBehaviorTests()
+    {
+        SystemClock.Sleep = (wait, _) => _waits.Add(wait);
+        SystemClock.SleepAsync = (wait, _) =>
+        {
+            _waits.Add(wait);
+            return Task.CompletedTask;
+        };
+    }
+
+    public void Dispose()
+    {
+        SystemClock.Reset();
+    }
+
+    [Fact]
+    public void OnSaveChanges_DatabaseLockedBriefly_WaitsTheConfiguredDurationsInOrder()
+    {
+        var attempts = 0;
+
+        _behavior.OnSaveChanges(null!, () =>
+        {
+            if (++attempts <= 5)
+            {
+                throw DatabaseLocked();
+            }
+        });
+
+        Assert.Equal(6, attempts);
+        AssertWaits(5);
+    }
+
+    [Fact]
+    public void OnSaveChanges_DatabaseStaysLocked_ThrowsTheDatabaseErrorAfterTheLastRetry()
+    {
+        var attempts = 0;
+
+        Assert.Throws<SqliteException>(() => _behavior.OnSaveChanges(null!, () =>
+        {
+            attempts++;
+            throw DatabaseLocked();
+        }));
+
+        Assert.Equal(_sleepDurations.Length + 1, attempts);
+        AssertWaits(_sleepDurations.Length);
+    }
+
+    [Fact]
+    public async Task OnSaveChangesAsync_DatabaseStaysLocked_ThrowsTheDatabaseErrorAfterTheLastRetry()
+    {
+        var attempts = 0;
+
+        await Assert.ThrowsAsync<SqliteException>(() => _behavior.OnSaveChangesAsync(null!, () =>
+        {
+            attempts++;
+            throw DatabaseLocked();
+        }));
+
+        Assert.Equal(_sleepDurations.Length + 1, attempts);
+        AssertWaits(_sleepDurations.Length);
+    }
+
+    private static SqliteException DatabaseLocked() => new("SQLite Error 5: 'database is locked'.", 5);
+
+    private void AssertWaits(int retries)
+    {
+        Assert.Equal(retries, _waits.Count);
+        for (var i = 0; i < retries; i++)
+        {
+            // The configured duration plus a jitter of less than half of it.
+            Assert.InRange(_waits[i], _sleepDurations[i], _sleepDurations[i] * 1.5);
+        }
+    }
+}