test: add regression tests for streaming sync retry backoff

Author: joshuabrink

Tests/PowerSync/PowerSync.Common.Tests/Client/Sync/StreamingSyncRetryTests.cs

@@ -0,0 +1,106 @@
+namespace PowerSync.Common.Tests.Client.Sync;
+
+using System.Collections.Concurrent;
+
+using PowerSync.Common.Client;
+using PowerSync.Common.Client.Connection;
+using PowerSync.Common.Client.Sync.Stream;
+using PowerSync.Common.Tests.Utils;
+using PowerSync.Common.Tests.Utils.Sync;
+
+/// <summary>
+/// dotnet test -v n --framework net8.0 --filter "StreamingSyncRetryTests"
+/// </summary>
+public class StreamingSyncRetryTests
+{
+    [Fact(Timeout = 15000)]
+    public async Task RetryLoop_AppliesDelayBetweenFailedAttempts()
+    {
+        const int retryDelayMs = 200;
+        const double tolerance = 0.75;
+
+        var attemptTimes = new ConcurrentQueue<DateTime>();
+        var attemptSignal = new SemaphoreSlim(0);
+
+        var dbFilename = $"sync-retry-{Guid.NewGuid():N}.db";
+        var throwing = new ThrowingRemote(new TestConnector(), attemptTimes, attemptSignal);
+
+        var db = new PowerSyncDatabase(new PowerSyncDatabaseOptions
+        {
+            Database = new SQLOpenOptions { DbFilename = dbFilename },
+            Schema = TestSchemaTodoList.AppSchema,
+            RemoteFactory = _ => throwing
+        });
+
+        try
+        {
+            await db.Init();
+
+            // Fire-and-forget: Connect() awaits Connected=true, which never fires
+            // because every iteration throws. The retry loop runs in the background.
+            _ = db.Connect(
+                new TestConnector(),
+                new PowerSyncConnectionOptions { RetryDelayMs = retryDelayMs }
+            );
+
+            for (int i = 0; i < 4; i++)
+            {
+                Assert.True(
+                    await attemptSignal.WaitAsync(TimeSpan.FromSeconds(5)),
+                    $"Did not observe attempt #{i + 1} within timeout — retry loop is not running"
+                );
+            }
+
+            var timestamps = attemptTimes.ToArray();
+            Assert.True(timestamps.Length >= 4);
+
+            for (int i = 1; i < timestamps.Length; i++)
+            {
+                var deltaMs = (timestamps[i] - timestamps[i - 1]).TotalMilliseconds;
+                Assert.True(
+                    deltaMs >= retryDelayMs * tolerance,
+                    $"Retry gap #{i} was {deltaMs:F0}ms, expected >= {retryDelayMs * tolerance:F0}ms (RetryDelayMs={retryDelayMs})"
+                );
+            }
+        }
+        finally
+        {
+            await db.Disconnect();
+            await db.Close();
+            DatabaseUtils.CleanDb(dbFilename);
+        }
+    }
+}
+
+internal sealed class ThrowingRemote : Remote
+{
+    private readonly ConcurrentQueue<DateTime> timestamps;
+    private readonly SemaphoreSlim signal;
+
+    public ThrowingRemote(
+        IPowerSyncBackendConnector connector,
+        ConcurrentQueue<DateTime> timestamps,
+        SemaphoreSlim signal
+    ) : base(connector)
+    {
+        this.timestamps = timestamps;
+        this.signal = signal;
+    }
+
+    public override Task<System.IO.Stream> PostStreamRaw(SyncStreamOptions options)
+    {
+        timestamps.Enqueue(DateTime.UtcNow);
+        signal.Release();
+        throw new HttpRequestException(
+            "HTTP InternalServerError: simulated [PSYNC_S2305] from ThrowingRemote"
+        );
+    }
+
+    public override Task<T> Get<T>(string path, Dictionary<string, string>? headers = null)
+    {
+        var response = new StreamingSyncImplementation.ApiResponse(
+            new StreamingSyncImplementation.ResponseData("1")
+        );
+        return Task.FromResult((T)(object)response);
+    }
+}