Refactored MockFileStream to simplify content synchronization logic and handle unflushed writes. Split a function to reduce complexity. Fixed code sniffs (especially insecure file path generation). Updated API baseline due to Read() and Length override. This should not be a breaking change.

Author: mistial-dev

src/TestableIO.System.IO.Abstractions.TestingHelpers/MockFileStream.cs

@@ -2,6 +2,7 @@
 using System.Threading;
 using System.Runtime.Versioning;
 using System.Security.AccessControl;
+using System.Linq;
 
 namespace System.IO.Abstractions.TestingHelpers;
 
@@ -75,6 +76,13 @@ public MockFileStream(
 
             var timeAdjustments = GetTimeAdjustmentsForFileStreamWhenFileExists(mode, access);
             mockFileDataAccessor.AdjustTimes(fileData, timeAdjustments);
+            
+            // For Truncate mode, clear the file contents first
+            if (mode == FileMode.Truncate)
+            {
+                fileData.Contents = new byte[0];
+            }
+            
             var existingContents = fileData.Contents;
             var keepExistingContents =
                 existingContents?.Length > 0 &&
@@ -145,7 +153,6 @@ public override long Length
     {
         get
         {
-            // Only refresh if needed to see latest file size from other streams
             RefreshFromSharedContentIfNeeded();
             return base.Length;
         }
@@ -374,112 +381,22 @@ private void RefreshFromSharedContent(MockFileData mockFileData = null)
             // This prevents unnecessary work and maintains performance
             if (mockFileData.ContentVersion != lastKnownContentVersion)
             {
-                // If we have unflushed writes, we need to preserve them when refreshing
-                // This handles the case where:
-                // 1. Stream A writes data but hasn't flushed
-                // 2. Stream B writes and flushes, updating shared content
-                // 3. Stream A needs to refresh but preserve its unflushed changes
-                byte[] preservedContent = null;
-                long preservedLength = 0;
                 long currentPosition = Position;
 
-                if (hasUnflushedWrites)
-                {
-                    // Save our current stream content to preserve unflushed writes
-                    preservedLength = base.Length;
-                    preservedContent = new byte[preservedLength];
-                    var originalPosition = Position;
-                    Position = 0;
-                    var totalBytesRead = 0;
-                    while (totalBytesRead < preservedLength)
-                    {
-                        var bytesRead = base.Read(preservedContent, totalBytesRead, (int)(preservedLength - totalBytesRead));
-                        if (bytesRead == 0)
-                        {
-                            break;
-                        }
-                        totalBytesRead += bytesRead;
-                    }
-                    Position = originalPosition;
-                }
+                // Preserve unflushed content if necessary
+                var (preservedContent, preservedLength) = PreserveUnflushedContent();
 
                 var sharedContent = mockFileData.Contents;
 
-                // Performance optimization: if we have no unflushed writes and the shared content
-                // is the same length as our current content, we might not need to do expensive copying
-                if (!hasUnflushedWrites && sharedContent?.Length == base.Length)
-                {
-                    // Quick content comparison for common case where only metadata changed
-                    bool contentSame = true;
-                    if (sharedContent.Length > 0 && sharedContent.Length <= 4096) // Only check small files
-                    {
-                        var currentPos = Position;
-                        Position = 0;
-                        var currentContent = new byte[base.Length];
-                        var bytesRead = base.Read(currentContent, 0, (int)base.Length);
-                        Position = currentPos;
-                        
-                        if (bytesRead == sharedContent.Length)
-                        {
-                            for (int i = 0; i < bytesRead; i++)
-                            {
-                                if (currentContent[i] != sharedContent[i])
-                                {
-                                    contentSame = false;
-                                    break;
-                                }
-                            }
-                        }
-                        else
-                        {
-                            contentSame = false;
-                        }
-                    }
-                    else
-                    {
-                        contentSame = false; // Don't compare large files
-                    }
-                    
-                    if (contentSame)
-                    {
-                        // Content is identical, just update version tracking and exit
-                        lastKnownContentVersion = mockFileData.ContentVersion;
-                        return;
-                    }
-                }
-                
-                // Start with shared content as the base - this gives us the latest changes from other streams
-                base.SetLength(0);
-                Position = 0;
-                if (sharedContent != null && sharedContent.Length > 0)
+                // Check if content is already the same (optimization for metadata-only changes)
+                if (IsContentIdentical(sharedContent))
                 {
-                    base.Write(sharedContent, 0, sharedContent.Length);
+                    lastKnownContentVersion = mockFileData.ContentVersion;
+                    return;
                 }
 
-                // If we had unflushed writes, we need to overlay them on the shared content
-                // This ensures our local changes take precedence over shared content
-                if (hasUnflushedWrites && preservedContent != null)
-                {
-                    // Optimization: if preserved content is same length or longer, just use it directly
-                    if (preservedLength >= (sharedContent?.Length ?? 0))
-                    {
-                        base.SetLength(0);
-                        Position = 0;
-                        base.Write(preservedContent, 0, (int)preservedLength);
-                    }
-                    else
-                    {
-                        // Need to merge: ensure stream is large enough
-                        if (base.Length < preservedLength)
-                        {
-                            base.SetLength(preservedLength);
-                        }
-                        
-                        // Apply our preserved content on top of the shared content
-                        Position = 0;
-                        base.Write(preservedContent, 0, (int)preservedLength);
-                    }
-                }
+                // Merge shared content with any preserved unflushed writes
+                MergeWithSharedContent(sharedContent, preservedContent, preservedLength);
 
                 // Restore position, but ensure it's within bounds of the new content
                 Position = Math.Min(currentPosition, base.Length);
@@ -491,6 +408,109 @@ private void RefreshFromSharedContent(MockFileData mockFileData = null)
         }
     }
 
+    /// <summary>
+    /// Preserves unflushed content from the current stream before refreshing from shared content.
+    /// </summary>
+    /// <returns>A tuple containing the preserved content and its length.</returns>
+    private (byte[] content, long length) PreserveUnflushedContent()
+    {
+        if (!hasUnflushedWrites)
+        {
+            return (null, 0);
+        }
+
+        // Save our current stream content to preserve unflushed writes
+        var preservedLength = base.Length;
+        var preservedContent = new byte[preservedLength];
+        var originalPosition = Position;
+        Position = 0;
+        var totalBytesRead = 0;
+        while (totalBytesRead < preservedLength)
+        {
+            var bytesRead = base.Read(preservedContent, totalBytesRead, (int)(preservedLength - totalBytesRead));
+            if (bytesRead == 0)
+            {
+                break;
+            }
+            totalBytesRead += bytesRead;
+        }
+        Position = originalPosition;
+        
+        return (preservedContent, preservedLength);
+    }
+
+    /// <summary>
+    /// Checks if the current content is identical to the shared content (optimization).
+    /// </summary>
+    /// <param name="sharedContent">The shared content to compare against.</param>
+    /// <returns>True if the content is identical, false otherwise.</returns>
+    private bool IsContentIdentical(byte[] sharedContent)
+    {
+        // Performance optimization: if we have no unflushed writes and the shared content
+        // is the same length as our current content, we might not need to do expensive copying
+        if (hasUnflushedWrites || sharedContent?.Length != base.Length)
+        {
+            return false;
+        }
+
+        // Quick content comparison for common case where only metadata changed
+        if (sharedContent.Length > 0 && sharedContent.Length <= 4096) // Only check small files
+        {
+            var currentPos = Position;
+            Position = 0;
+            var currentContent = new byte[base.Length];
+            var bytesRead = base.Read(currentContent, 0, (int)base.Length);
+            Position = currentPos;
+            
+            return bytesRead == sharedContent.Length && 
+                   currentContent.Take(bytesRead).SequenceEqual(sharedContent);
+        }
+
+        return false; // Don't compare large files
+    }
+
+    /// <summary>
+    /// Merges the shared content with any preserved unflushed writes.
+    /// </summary>
+    /// <param name="sharedContent">The shared content from MockFileData.</param>
+    /// <param name="preservedContent">Any preserved unflushed content.</param>
+    /// <param name="preservedLength">The length of the preserved content.</param>
+    private void MergeWithSharedContent(byte[] sharedContent, byte[] preservedContent, long preservedLength)
+    {
+        // Start with shared content as the base - this gives us the latest changes from other streams
+        base.SetLength(0);
+        Position = 0;
+        if (sharedContent != null && sharedContent.Length > 0)
+        {
+            base.Write(sharedContent, 0, sharedContent.Length);
+        }
+        
+        // If we had unflushed writes, we need to overlay them on the shared content
+        // This ensures our local changes take precedence over shared content
+        if (hasUnflushedWrites && preservedContent != null)
+        {
+            // Optimization: if preserved content is same length or longer, just use it directly
+            if (preservedLength >= (sharedContent?.Length ?? 0))
+            {
+                base.SetLength(0);
+                Position = 0;
+                base.Write(preservedContent, 0, (int)preservedLength);
+            }
+            else
+            {
+                // Need to merge: ensure stream is large enough
+                if (base.Length < preservedLength)
+                {
+                    base.SetLength(preservedLength);
+                }
+                
+                // Apply our preserved content on top of the shared content
+                Position = 0;
+                base.Write(preservedContent, 0, (int)preservedLength);
+            }
+        }
+    }
+
     /// <summary>
     /// Flushes this stream's content to the shared file data, implementing proper synchronization for FileShare.ReadWrite.
     /// 

tests/TestableIO.System.IO.Abstractions.Api.Tests/Expected/TestableIO.System.IO.Abstractions.TestingHelpers_net472.txt

@@ -300,6 +300,7 @@ namespace System.IO.Abstractions.TestingHelpers
         public MockFileStream(System.IO.Abstractions.TestingHelpers.IMockFileDataAccessor mockFileDataAccessor, string path, System.IO.FileMode mode, System.IO.FileAccess access = 3, System.IO.FileOptions options = 0) { }
         public override bool CanRead { get; }
         public override bool CanWrite { get; }
+        public override long Length { get; }
         public static System.IO.Abstractions.FileSystemStream Null { get; }
         protected override void Dispose(bool disposing) { }
         public override void EndWrite(System.IAsyncResult asyncResult) { }

tests/TestableIO.System.IO.Abstractions.Api.Tests/Expected/TestableIO.System.IO.Abstractions.TestingHelpers_net6.0.txt

@@ -349,6 +349,7 @@ namespace System.IO.Abstractions.TestingHelpers
         public MockFileStream(System.IO.Abstractions.TestingHelpers.IMockFileDataAccessor mockFileDataAccessor, string path, System.IO.FileMode mode, System.IO.FileAccess access = 3, System.IO.FileOptions options = 0) { }
         public override bool CanRead { get; }
         public override bool CanWrite { get; }
+        public override long Length { get; }
         public static System.IO.Abstractions.FileSystemStream Null { get; }
         protected override void Dispose(bool disposing) { }
         public override void EndWrite(System.IAsyncResult asyncResult) { }
@@ -359,6 +360,7 @@ namespace System.IO.Abstractions.TestingHelpers
         public object GetAccessControl() { }
         [System.Runtime.Versioning.SupportedOSPlatform("windows")]
         public object GetAccessControl(System.IO.Abstractions.IFileSystemAclSupport.AccessControlSections includeSections) { }
+        public override int Read(System.Span<byte> buffer) { }
         public override int Read(byte[] buffer, int offset, int count) { }
         [System.Runtime.Versioning.SupportedOSPlatform("windows")]
         public void SetAccessControl(object value) { }

tests/TestableIO.System.IO.Abstractions.Api.Tests/Expected/TestableIO.System.IO.Abstractions.TestingHelpers_net8.0.txt

@@ -373,6 +373,7 @@ namespace System.IO.Abstractions.TestingHelpers
         public MockFileStream(System.IO.Abstractions.TestingHelpers.IMockFileDataAccessor mockFileDataAccessor, string path, System.IO.FileMode mode, System.IO.FileAccess access = 3, System.IO.FileOptions options = 0) { }
         public override bool CanRead { get; }
         public override bool CanWrite { get; }
+        public override long Length { get; }
         public static System.IO.Abstractions.FileSystemStream Null { get; }
         protected override void Dispose(bool disposing) { }
         public override void EndWrite(System.IAsyncResult asyncResult) { }
@@ -383,6 +384,7 @@ namespace System.IO.Abstractions.TestingHelpers
         public object GetAccessControl() { }
         [System.Runtime.Versioning.SupportedOSPlatform("windows")]
         public object GetAccessControl(System.IO.Abstractions.IFileSystemAclSupport.AccessControlSections includeSections) { }
+        public override int Read(System.Span<byte> buffer) { }
         public override int Read(byte[] buffer, int offset, int count) { }
         [System.Runtime.Versioning.SupportedOSPlatform("windows")]
         public void SetAccessControl(object value) { }

tests/TestableIO.System.IO.Abstractions.Api.Tests/Expected/TestableIO.System.IO.Abstractions.TestingHelpers_net9.0.txt

@@ -387,6 +387,7 @@ namespace System.IO.Abstractions.TestingHelpers
         public MockFileStream(System.IO.Abstractions.TestingHelpers.IMockFileDataAccessor mockFileDataAccessor, string path, System.IO.FileMode mode, System.IO.FileAccess access = 3, System.IO.FileOptions options = 0) { }
         public override bool CanRead { get; }
         public override bool CanWrite { get; }
+        public override long Length { get; }
         public static System.IO.Abstractions.FileSystemStream Null { get; }
         protected override void Dispose(bool disposing) { }
         public override void EndWrite(System.IAsyncResult asyncResult) { }
@@ -397,6 +398,7 @@ namespace System.IO.Abstractions.TestingHelpers
         public object GetAccessControl() { }
         [System.Runtime.Versioning.SupportedOSPlatform("windows")]
         public object GetAccessControl(System.IO.Abstractions.IFileSystemAclSupport.AccessControlSections includeSections) { }
+        public override int Read(System.Span<byte> buffer) { }
         public override int Read(byte[] buffer, int offset, int count) { }
         [System.Runtime.Versioning.SupportedOSPlatform("windows")]
         public void SetAccessControl(object value) { }

tests/TestableIO.System.IO.Abstractions.Api.Tests/Expected/TestableIO.System.IO.Abstractions.TestingHelpers_netstandard2.0.txt

@@ -300,6 +300,7 @@ namespace System.IO.Abstractions.TestingHelpers
         public MockFileStream(System.IO.Abstractions.TestingHelpers.IMockFileDataAccessor mockFileDataAccessor, string path, System.IO.FileMode mode, System.IO.FileAccess access = 3, System.IO.FileOptions options = 0) { }
         public override bool CanRead { get; }
         public override bool CanWrite { get; }
+        public override long Length { get; }
         public static System.IO.Abstractions.FileSystemStream Null { get; }
         protected override void Dispose(bool disposing) { }
         public override void EndWrite(System.IAsyncResult asyncResult) { }

tests/TestableIO.System.IO.Abstractions.Api.Tests/Expected/TestableIO.System.IO.Abstractions.TestingHelpers_netstandard2.1.txt

@@ -326,6 +326,7 @@ namespace System.IO.Abstractions.TestingHelpers
         public MockFileStream(System.IO.Abstractions.TestingHelpers.IMockFileDataAccessor mockFileDataAccessor, string path, System.IO.FileMode mode, System.IO.FileAccess access = 3, System.IO.FileOptions options = 0) { }
         public override bool CanRead { get; }
         public override bool CanWrite { get; }
+        public override long Length { get; }
         public static System.IO.Abstractions.FileSystemStream Null { get; }
         protected override void Dispose(bool disposing) { }
         public override void EndWrite(System.IAsyncResult asyncResult) { }
@@ -334,6 +335,7 @@ namespace System.IO.Abstractions.TestingHelpers
         public override System.Threading.Tasks.Task FlushAsync(System.Threading.CancellationToken cancellationToken) { }
         public object GetAccessControl() { }
         public object GetAccessControl(System.IO.Abstractions.IFileSystemAclSupport.AccessControlSections includeSections) { }
+        public override int Read(System.Span<byte> buffer) { }
         public override int Read(byte[] buffer, int offset, int count) { }
         public void SetAccessControl(object value) { }
         public override void SetLength(long value) { }