Clean up and formatting

Author: rameel

src/Ramstack.FileSystem.Amazon/S3UploadStream.cs

@@ -10,13 +10,11 @@ namespace Ramstack.FileSystem.Amazon;
 
 /// <summary>
 /// Represents a stream for uploading data to Amazon S3 using multipart upload.
-/// This stream accumulates data in a temporary buffer and uploads it to S3 in parts
-/// once the buffer reaches a predefined size.
 /// </summary>
 internal sealed class S3UploadStream : Stream
 {
     // https://docs.aws.amazon.com/AmazonS3/latest/userguide/qfacts.html
-    private const long PartSize = 5L * 1024 * 1024;
+    private const long MinPartSize = 5L * 1024 * 1024;
 
     private readonly IAmazonS3 _client;
     private readonly string _bucketName;
@@ -82,7 +80,7 @@ public S3UploadStream(IAmazonS3 client, string bucketName, string key, string up
             FileShare.None,
             bufferSize: 4096,
             FileOptions.DeleteOnClose
-            | FileOptions.Asynchronous);
+                | FileOptions.Asynchronous);
     }
 
     /// <inheritdoc />
@@ -103,7 +101,7 @@ public override void Write(ReadOnlySpan<byte> buffer)
         {
             _stream.Write(buffer);
 
-            if (_stream.Length >= PartSize)
+            if (_stream.Length >= MinPartSize)
                 UploadPart();
         }
         catch (Exception exception)
@@ -123,7 +121,7 @@ public override async ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, Cancella
         try
         {
             await _stream.WriteAsync(buffer, cancellationToken).ConfigureAwait(false);
-            if (_stream.Length >= PartSize)
+            if (_stream.Length >= MinPartSize)
                 await UploadPartAsync(cancellationToken).ConfigureAwait(false);
         }
         catch (Exception exception)

tests/Ramstack.FileSystem.Amazon.Tests/WritableAmazonFileSystemTests.cs

@@ -193,82 +193,92 @@ await reader.ReadToEndAsync(),
         await destination.DeleteAsync();
     }
 
-
     [Test]
     public async Task File_OpenWrite_FlushDoesNotCauseUndersizedParts()
     {
         using var fs = GetFileSystem();
 
-        var content = "Hello, World!";
+        const string Content = "Hello, World!";
 
         {
             await using var stream = await fs.OpenWriteAsync("/flush-test.txt");
             await using var writer = new StreamWriter(stream);
 
             // Write small data and flush multiple times.
             // Flush should be a no-op and not upload undersized parts.
-            await writer.WriteAsync(content[..5]);
-            await writer.FlushAsync();
-            await writer.WriteAsync(content[5..]);
-            await writer.FlushAsync();
+            foreach (var ch in Content)
+            {
+                await writer.WriteAsync(ch);
+                await writer.FlushAsync();
+            }
         }
-
         {
-            var file = fs.GetFile("/flush-test.txt");
-            Assert.That(await file.ExistsAsync(), Is.True);
-
             // ReSharper disable once UseAwaitUsing
-            using var stream = await file.OpenReadAsync();
+            using var stream = await fs.OpenReadAsync("/flush-test.txt");
             using var reader = new StreamReader(stream);
-            Assert.That(await reader.ReadToEndAsync(), Is.EqualTo(content));
 
-            await file.DeleteAsync();
+            Assert.That(await reader.ReadToEndAsync(), Is.EqualTo(Content));
         }
+
+        await fs.DeleteFileAsync("/flush-test.txt");
     }
 
     [Test]
     public async Task File_OpenWrite_FlushWithMultipartUpload()
     {
         using var fs = GetFileSystem();
 
-        // Write more than 5 MiB to trigger multipart upload,
-        // with Flush calls between writes.
-        var chunk = new byte[2 * 1024 * 1024];
+        const int Count = 5;
+        const string FileName = "/flush-multipart-test.bin";
+
+        var chunk = new byte[3 * 1024 * 1024];
         Random.Shared.NextBytes(chunk);
 
         {
-            await using var stream = await fs.OpenWriteAsync("/flush-multipart-test.bin");
+            await using var stream = await fs.OpenWriteAsync(FileName);
+            for (var i = 0; i < Count; i++)
+                await stream.WriteAsync(chunk);
+        }
+
+        {
+            var file = fs.GetFile(FileName);
+
+            Assert.That(await file.ExistsAsync(), Is.True);
+            Assert.That(await file.GetLengthAsync(), Is.EqualTo(chunk.Length * Count));
 
-            // Write 4 chunks (8 MiB total) with flushes in between.
-            // Without the fix, each flush would upload an undersized part
-            // and CompleteMultipartUpload would fail.
-            for (var i = 0; i < 4; i++)
+            // ReSharper disable once UseAwaitUsing
+            using var stream = await file.OpenReadAsync();
+
+            var bytes = new byte[chunk.Length];
+
+            for (var i = 0; i < Count; i++)
             {
-                await stream.WriteAsync(chunk);
-                await stream.FlushAsync();
+                var n = await ReadBlockAsync(stream, bytes);
+                Assert.That(n, Is.EqualTo(bytes.Length));
+
+                Assert.That(
+                    bytes.AsSpan().SequenceEqual(chunk),
+                    Is.True);
             }
         }
 
-        var file = fs.GetFile("/flush-multipart-test.bin");
-        Assert.That(await file.ExistsAsync(), Is.True);
-        Assert.That(await file.GetLengthAsync(), Is.EqualTo(chunk.Length * 4));
-
-        await file.DeleteAsync();
-    }
+        await fs.DeleteFileAsync(FileName);
 
-    [Test]
-    public async Task File_OpenWrite_EmptyFileWithFlush()
-    {
-        using var fs = GetFileSystem();
+        static async Task<int> ReadBlockAsync(Stream stream, Memory<byte> memory)
+        {
+            var count = memory.Length;
 
-        await using (var stream = await fs.OpenWriteAsync("/empty-flush-test.txt"))
-            await stream.FlushAsync();
+            while (!memory.IsEmpty)
+            {
+                var n = await stream.ReadAsync(memory);
+                if (n == 0)
+                    return 0;
 
-        var file = fs.GetFile("/empty-flush-test.txt");
-        Assert.That(await file.ExistsAsync(), Is.True);
-        Assert.That(await file.GetLengthAsync(), Is.EqualTo(0));
+                memory = memory[n..];
+            }
 
-        await file.DeleteAsync();
+            return count;
+        }
     }
 
     [Test]