test: broaden transformed stream reader coverage

tests/SharpCompress.Test/ReaderFactoryTests.cs

@@ -1,14 +1,21 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Text;
 using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Compressors;
+using SharpCompress.Compressors.Deflate;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Rar;
+using SharpCompress.Readers.Tar;
 using SharpCompress.Test.Mocks;
+using SharpCompress.Writers.Tar;
 using Xunit;
 
 namespace SharpCompress.Test;
 
-public class ReaderFactoryTests
+public class ReaderFactoryTests : TestBase
 {
     [Fact]
     public void OpenReader_Stream_Throws_On_Unreadable_Stream()
@@ -38,4 +45,85 @@ public class ReaderFactoryTests
             RarReader.OpenReader([unreadable, readable]).MoveToNextEntry()
         );
     }
+
+    [Fact]
+    public void OpenReader_DeflateStream_WithTarPayload_DetectsTarReader()
+    {
+        using var compressedStream = new MemoryStream(CompressWithDeflate(CreateTarPayload()));
+        using var deflateStream = new DeflateStream(
+            compressedStream,
+            CompressionMode.Decompress,
+            CompressionLevel.Default,
+            leaveOpen: false
+        );
+        using var reader = ReaderFactory.OpenReader(deflateStream);
+
+        Assert.IsType<TarReader>(reader);
+        Assert.Equal(
+            new Dictionary<string, string>
+            {
+                ["alpha.txt"] = "alpha",
+                ["nested/beta.txt"] = "beta",
+            },
+            ReadAllFiles(reader)
+        );
+    }
+
+    private static Dictionary<string, string> ReadAllFiles(IReader reader)
+    {
+        var entries = new Dictionary<string, string>();
+        while (reader.MoveToNextEntry())
+        {
+            if (reader.Entry.IsDirectory)
+            {
+                continue;
+            }
+
+            using var entryStream = reader.OpenEntryStream();
+            using var streamReader = new StreamReader(entryStream, Encoding.UTF8);
+            entries.Add(reader.Entry.Key!, streamReader.ReadToEnd());
+        }
+
+        return entries;
+    }
+
+    private static byte[] CreateTarPayload()
+    {
+        var archiveEncoding = new ArchiveEncoding { Default = Encoding.UTF8 };
+        var tarWriterOptions = new TarWriterOptions(CompressionType.None, true)
+        {
+            ArchiveEncoding = archiveEncoding,
+        };
+
+        using var memoryStream = new MemoryStream();
+        using (var tarWriter = new TarWriter(memoryStream, tarWriterOptions))
+        using (var alphaStream = new MemoryStream(Encoding.UTF8.GetBytes("alpha")))
+        using (var betaStream = new MemoryStream(Encoding.UTF8.GetBytes("beta")))
+        {
+            tarWriter.Write("alpha.txt", alphaStream, null);
+            tarWriter.Write("nested/beta.txt", betaStream, null);
+        }
+
+        return memoryStream.ToArray();
+    }
+
+    private static byte[] CompressWithDeflate(byte[] bytes)
+    {
+        using var sourceStream = new MemoryStream(bytes);
+        using var deflateStream = new DeflateStream(
+            sourceStream,
+            CompressionMode.Compress,
+            CompressionLevel.Default
+        );
+        using var compressedStream = new MemoryStream();
+
+        var buffer = new byte[4096];
+        int read;
+        while ((read = deflateStream.Read(buffer, 0, buffer.Length)) > 0)
+        {
+            compressedStream.Write(buffer, 0, read);
+        }
+
+        return compressedStream.ToArray();
+    }
 }

tests/SharpCompress.Test/Streams/SharpCompressStreamFactoryTest.cs

@@ -86,13 +86,14 @@ public class SharpCompressStreamFactoryTest
     }
 
     [Fact]
-    public void Create_WithIStreamStack_UnwrapsSharpCompressStream()
+    public void Create_WithIStreamStack_Wraps_Outer_Stream_Instead_Of_Unwrapping_Inner_Stream()
     {
         var ms = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
         var sharpStream = SharpCompressStream.CreateNonDisposing(ms);
         var wrappedStream = new IStreamStackMock(sharpStream);
-        var stream = SharpCompressStream.Create(wrappedStream);
-        Assert.Same(sharpStream, stream);
+        var result = SharpCompressStream.Create(wrappedStream);
+        Assert.NotSame(sharpStream, result);
+        Assert.Same(wrappedStream, result.BaseStream());
     }
 
     [Fact]
@@ -127,13 +128,14 @@ public class SharpCompressStreamFactoryTest
     }
 
     [Fact]
-    public void Create_WithIStreamStack_ReturnsUnderlyingSharpCompressStream()
+    public void Create_WithIStreamStack_Containing_SharpCompressStream_Preserves_Outer_Stream()
     {
         var ms = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
         var sharpStream = SharpCompressStream.Create(ms);
         var wrappedStream = new IStreamStackMock(sharpStream);
         var result = SharpCompressStream.Create(wrappedStream);
-        Assert.Same(sharpStream, result);
+        Assert.NotSame(sharpStream, result);
+        Assert.Same(wrappedStream, result.BaseStream());
     }
 
     [Fact]