fix(cms-upload): scope InfiniteTimeSpan to upload client; add response-wait budget after body completes

DeepDrftTests/ProgressStreamContentTests.cs

@@ -90,6 +90,97 @@ public class ProgressStreamContentTests
         Assert.That(idleCts.IsCancellationRequested, Is.True);
     }
 
+    // --- Two-phase deadline switching (Finding 1 regression test) ---
+    // After the last body byte is reported the idle timer must be disarmed and the response-wait
+    // budget must be armed. This test simulates the exact scenario that triggered Finding 1:
+    // the body streams quickly, then a long server-side lag (standing in for AudioProcessor +
+    // vault write + SQL persist) follows. The idle window is short; the response budget is long.
+    // With the fix the operation must complete; without it idleCts would fire during the lag.
+
+    [Test]
+    public async Task PostBodyLag_DoesNotTriggerIdleTimeout_WhenResponseBudgetIsLarger()
+    {
+        var idle = TimeSpan.FromMilliseconds(150);
+        var responseBudget = TimeSpan.FromMilliseconds(600);
+
+        using var idleCts = new CancellationTokenSource();
+        idleCts.CancelAfter(idle);
+        using var responseCts = new CancellationTokenSource();
+        // responseCts starts disarmed — same as in CmsTrackService.
+        using var sendCts = CancellationTokenSource.CreateLinkedTokenSource(idleCts.Token, responseCts.Token);
+
+        const long contentLength = 4096;
+        var source = new PacedStream(chunkCount: 1, chunkSize: (int)contentLength, delayPerChunk: TimeSpan.FromMilliseconds(10));
+        var content = new ProgressStreamContent(source, contentLength, written =>
+        {
+            if (written < contentLength)
+            {
+                idleCts.CancelAfter(idle);
+            }
+            else
+            {
+                // Body complete — disarm idle, arm response budget (mirrors CmsTrackService).
+                idleCts.CancelAfter(Timeout.InfiniteTimeSpan);
+                responseCts.CancelAfter(responseBudget);
+            }
+        });
+
+        using var sink = new MemoryStream();
+        await content.CopyToAsync(sink, sendCts.Token);
+
+        // Body is done. Simulate a slow server (longer than idle window, shorter than response budget).
+        var serverLag = TimeSpan.FromMilliseconds(300); // > idle (150 ms), < response budget (600 ms)
+        await Task.Delay(serverLag, sendCts.Token);
+
+        Assert.That(sendCts.IsCancellationRequested, Is.False,
+            "A post-body server lag within the response budget must not cancel the send token.");
+        Assert.That(idleCts.IsCancellationRequested, Is.False,
+            "The idle CTS must be disarmed after body completes.");
+        Assert.That(responseCts.IsCancellationRequested, Is.False,
+            "The response CTS must not have fired — server lag was within the response budget.");
+    }
+
+    [Test]
+    public async Task PostBodyLag_CancelsViaResponseCts_WhenResponseBudgetExceeded()
+    {
+        var idle = TimeSpan.FromMilliseconds(200);
+        var responseBudget = TimeSpan.FromMilliseconds(150);
+
+        using var idleCts = new CancellationTokenSource();
+        idleCts.CancelAfter(idle);
+        using var responseCts = new CancellationTokenSource();
+        using var sendCts = CancellationTokenSource.CreateLinkedTokenSource(idleCts.Token, responseCts.Token);
+
+        const long contentLength = 4096;
+        var source = new PacedStream(chunkCount: 1, chunkSize: (int)contentLength, delayPerChunk: TimeSpan.FromMilliseconds(10));
+        var content = new ProgressStreamContent(source, contentLength, written =>
+        {
+            if (written < contentLength)
+            {
+                idleCts.CancelAfter(idle);
+            }
+            else
+            {
+                idleCts.CancelAfter(Timeout.InfiniteTimeSpan);
+                responseCts.CancelAfter(responseBudget);
+            }
+        });
+
+        using var sink = new MemoryStream();
+        await content.CopyToAsync(sink, sendCts.Token);
+
+        // Simulate a slow server that exceeds the response budget.
+        var serverLag = TimeSpan.FromMilliseconds(400); // > response budget (150 ms)
+        Assert.That(
+            async () => await Task.Delay(serverLag, sendCts.Token),
+            Throws.InstanceOf<OperationCanceledException>(),
+            "A post-body lag exceeding the response budget must cancel via sendCts.");
+        Assert.That(responseCts.IsCancellationRequested, Is.True,
+            "responseCts must be the source of the cancellation, not idleCts.");
+        Assert.That(idleCts.IsCancellationRequested, Is.False,
+            "idleCts must remain disarmed — the response budget fired, not the idle window.");
+    }
+
     /// <summary>
     /// A read-only stream that yields a fixed number of equal chunks, pausing between reads to emulate
     /// network pacing. Optionally inserts a longer stall before a given chunk to emulate a stalled link.