[fix] Improve upload resilience coverage

Cover FileSlicer cancellation cleanup paths and address the async disposal warning reported by SonarCloud.

Made-with: Cursor

Author: paul-fresquet

src/ByteSync.Client/Services/Communications/Transfers/Uploading/FileSlicer.cs

@@ -169,7 +169,7 @@ private async Task<bool> TryWriteSliceAsync(FileUploaderSlice fileUploaderSlice)
         }
         catch (ChannelClosedException) when (_exceptionOccurred.WaitOne(0))
         {
-            fileUploaderSlice.MemoryStream.Dispose();
+            await fileUploaderSlice.MemoryStream.DisposeAsync();
 
             return false;
         }

src/ByteSync.Client/Services/Communications/Transfers/Uploading/UploadAttemptTimeoutPolicy.cs

@@ -19,7 +19,7 @@ public static int ComputeTimeoutSeconds(long sliceLengthBytes, int attempt, int
         }
 
         var staleChunkPenalty = ComputeStaleChunkPenaltySeconds(sliceLengthBytes, currentChunkSizeBytes);
-        timeoutSec += (attempt - 1) * RetryGrowthSeconds + staleChunkPenalty;
+        timeoutSec += (long)(attempt - 1) * RetryGrowthSeconds + staleChunkPenalty;
 
         return (int)Math.Clamp(timeoutSec, AttemptTimeoutFloorSeconds, AttemptTimeoutCeilingSeconds);
     }

tests/ByteSync.Client.UnitTests/Services/Communications/Transfers/Uploading/FileSlicerTests.cs

@@ -168,7 +168,57 @@ public async Task SliceAndEncryptAsync_WithNoSlices_ShouldCompleteNormally()
         // Channel should be completed
         _availableSlices.Reader.Completion.IsCompleted.Should().BeTrue();
     }
-    
+
+    [Test]
+    public async Task SliceAndEncryptAsync_WhenChannelClosesAfterSliceCreated_ShouldDisposeSlice()
+    {
+        // Arrange
+        var stream = new MemoryStream(new byte[128]);
+        var slice = new FileUploaderSlice(1, stream);
+
+        _mockSlicerEncrypter.Setup(x => x.SliceAndEncrypt())
+            .Callback(() =>
+            {
+                _exceptionOccurred.Set();
+                _availableSlices.Writer.TryComplete();
+            })
+            .ReturnsAsync(slice);
+
+        // Act
+        await _fileSlicer.SliceAndEncryptAsync(_sharedFileDefinition, _progressState);
+
+        // Assert
+        _progressState.TotalCreatedSlices.Should().Be(1);
+        var readDisposedStream = () => _ = stream.Length;
+        readDisposedStream.Should().Throw<ObjectDisposedException>();
+    }
+
+    [Test]
+    public async Task SliceAndEncryptAdaptiveAsync_WhenChannelClosesAfterSliceCreated_ShouldDisposeSlice()
+    {
+        // Arrange
+        var stream = new MemoryStream(new byte[128]);
+        var slice = new FileUploaderSlice(1, stream);
+
+        _mockAdaptiveController.Setup(x => x.CurrentChunkSizeBytes).Returns(64 * 1024);
+        _mockAdaptiveController.Setup(x => x.GetNextChunkSizeBytes()).Returns(64 * 1024);
+        _mockSlicerEncrypter.Setup(x => x.SliceAndEncrypt())
+            .Callback(() =>
+            {
+                _exceptionOccurred.Set();
+                _availableSlices.Writer.TryComplete();
+            })
+            .ReturnsAsync(slice);
+
+        // Act
+        await _fileSlicer.SliceAndEncryptAdaptiveAsync(_sharedFileDefinition, _progressState);
+
+        // Assert
+        _progressState.TotalCreatedSlices.Should().Be(1);
+        var readDisposedStream = () => _ = stream.Length;
+        readDisposedStream.Should().Throw<ObjectDisposedException>();
+    }
+
     [Test]
     public async Task SliceAndEncryptAsync_WithMultipleSlices_ShouldProcessAllSlices()
     {