Implemented snapshot stream support.

src/Snapshooter/Core/Serialization/MemoryStreamJsonConverter.cs

@@ -0,0 +1,36 @@
+using System;
+using System.IO;
+using Newtonsoft.Json;
+
+namespace Snapshooter.Core.Serialization;
+
+public class MemoryStreamJsonConverter : JsonConverter
+{
+    public override bool CanConvert(Type objectType)
+    {
+        return typeof(MemoryStream).IsAssignableFrom(objectType);
+    }
+
+    public override object ReadJson(
+        JsonReader reader,
+        Type objectType,
+        object existingValue,
+        JsonSerializer serializer)
+    {
+        var bytes = serializer.Deserialize<byte[]>(reader);
+
+        return bytes != null ?
+            new MemoryStream(bytes) :
+            new MemoryStream();
+    }
+
+    public override void WriteJson(
+        JsonWriter writer,
+        object value,
+        JsonSerializer serializer)
+    {
+        var bytes = ((MemoryStream)value).ToArray();
+
+        serializer.Serialize(writer, bytes);
+    }
+}

src/Snapshooter/Core/Serialization/SnapshotSerializerSettings.cs

@@ -1,60 +1,65 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
 using Snapshooter.Extensions;
 
-namespace Snapshooter.Core.Serialization
+namespace Snapshooter.Core.Serialization;
+
+/// <summary>
+/// </summary>
+public abstract class SnapshotSerializerSettings
 {
+    public virtual int Order { get; } = 1;
+
+    public virtual bool Active { get; } = true;
+
     /// <summary>
     /// </summary>
-    public abstract class SnapshotSerializerSettings
+    public static JsonSerializerSettings DefaultJsonSerializerSettings =>
+        new JsonSerializerSettings
+        {
+            ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
+            Formatting = Formatting.Indented,
+            NullValueHandling = NullValueHandling.Include,
+            DateFormatHandling = DateFormatHandling.IsoDateFormat,
+            Culture = CultureInfo.InvariantCulture,
+            ContractResolver = ChildFirstContractResolver.Instance,
+            Converters = new List<JsonConverter>
+                {
+                    new StringEnumConverter(),
+                    new MemoryStreamJsonConverter(),
+                    new StreamJsonConverter()
+                }
+        };
+
+    public abstract JsonSerializerSettings Extend(JsonSerializerSettings settings);
+
+    private class ChildFirstContractResolver : DefaultContractResolver
     {
-        public virtual int Order { get; } = 1;
+        static ChildFirstContractResolver() { Instance = new ChildFirstContractResolver(); }
 
-        public virtual bool Active { get; } = true;
+        public static ChildFirstContractResolver Instance { get; }
 
-        /// <summary>
-        /// </summary>
-        public static JsonSerializerSettings DefaultJsonSerializerSettings =>
-            new JsonSerializerSettings
-            {
-                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
-                Formatting = Formatting.Indented,
-                NullValueHandling = NullValueHandling.Include,
-                DateFormatHandling = DateFormatHandling.IsoDateFormat,
-                Culture = CultureInfo.InvariantCulture,
-                ContractResolver = ChildFirstContractResolver.Instance,
-                Converters = new List<JsonConverter> {new StringEnumConverter()}                
-            };
-
-        public abstract JsonSerializerSettings Extend(JsonSerializerSettings settings);
-
-        private class ChildFirstContractResolver : DefaultContractResolver
+        protected override IList<JsonProperty> CreateProperties(
+            Type type, MemberSerialization memberSerialization)
         {
-            static ChildFirstContractResolver() { Instance = new ChildFirstContractResolver(); }
+            IList<JsonProperty> properties = base.CreateProperties(type, memberSerialization);
 
-            public static ChildFirstContractResolver Instance { get; }
-
-            protected override IList<JsonProperty> CreateProperties(
-                Type type, MemberSerialization memberSerialization)
+            if (properties != null)
             {
-                IList<JsonProperty> properties = base.CreateProperties(type, memberSerialization);
-
-                if (properties != null)
+                properties = properties.OrderBy(p =>
                 {
-                    properties = properties.OrderBy(p =>
-                    {
-                        IEnumerable<Type> d = ((Type)p.DeclaringType).BaseTypesAndSelf().ToList();
-                        return 1000 - d.Count();
-                    }).ToList();
-                }
-
-                return properties;
+                    IEnumerable<Type> d = ((Type)p.DeclaringType).BaseTypesAndSelf().ToList();
+                    return 1000 - d.Count();
+                }).ToList();
             }
+
+            return properties;
         }
     }
 }

src/Snapshooter/Core/Serialization/StreamJsonConverter.cs

@@ -0,0 +1,39 @@
+using System;
+using System.IO;
+using Newtonsoft.Json;
+
+namespace Snapshooter.Core.Serialization;
+
+public class StreamJsonConverter : JsonConverter
+{
+    public override bool CanConvert(Type objectType)
+    {
+        return typeof(Stream).IsAssignableFrom(objectType);
+    }
+
+    public override object ReadJson(
+        JsonReader reader,
+        Type objectType,
+        object existingValue,
+        JsonSerializer serializer)
+    {
+        var bytes = serializer.Deserialize<byte[]>(reader);
+
+        return bytes != null ?
+            new MemoryStream(bytes) :
+            new MemoryStream();
+    }
+
+    public override void WriteJson(
+        JsonWriter writer,
+        object value,
+        JsonSerializer serializer)
+    {
+        using var stream = (Stream)value;
+
+        byte[] bytes = new byte[stream.Length];
+        stream.Read(bytes, 0, bytes.Length);
+
+        serializer.Serialize(writer, bytes);
+    }
+}

test/Snapshooter.Tests.Data/TestFileLoader.cs

@@ -54,6 +54,13 @@ public static string LoadTextFile(string fileName)
         }
 
         private static T LoadResourceFile<T>(string fileName, Func<Stream, T> streamConverter)
+        {
+            Stream resourceStream = LoadResourceFile(fileName);
+
+            return streamConverter(resourceStream);
+        }
+
+        private static Stream LoadResourceFile(string fileName)
         {
             Assembly assembly = typeof(TestFileLoader).GetTypeInfo().Assembly;
 
@@ -79,8 +86,7 @@ private static T LoadResourceFile<T>(string fileName, Func<Stream, T> streamConv
                     $"for file {resourceName} could be found.");
             }
 
-            return streamConverter(resourceStream);
-
+            return resourceStream;
         }
     }
 }

test/Snapshooter.Xunit.Tests/Helpers/SnapshotDefaultNameResolver.cs

@@ -1,22 +1,13 @@
-using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Snapshooter.Xunit.Tests.Helpers
 {
     internal static class SnapshotDefaultNameResolver
     {
         public static string ResolveSnapshotDefaultName()
         {
-            var snapshotFullNameResolver =
-                new SnapshotFullNameResolver(
-                    new XunitSnapshotFullNameReader());
-
             SnapshotFullName snapshotFullName =
-                snapshotFullNameResolver.ResolveSnapshotFullName();
+                ResolveSnapshotDefaultFullName();
 
             string snapshotFileName = Path.Combine(
                 snapshotFullName.FolderPath,
@@ -25,5 +16,17 @@ public static string ResolveSnapshotDefaultName()
 
             return snapshotFileName;
         }
+
+        public static SnapshotFullName ResolveSnapshotDefaultFullName()
+        {
+            var snapshotFullNameResolver =
+                new SnapshotFullNameResolver(
+                    new XunitSnapshotFullNameReader());
+
+            SnapshotFullName snapshotFullName =
+                snapshotFullNameResolver.ResolveSnapshotFullName();
+
+            return snapshotFullName;
+        }
     }
 }

test/Snapshooter.Xunit.Tests/SnapshotTests.cs

@@ -2,9 +2,11 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text;
 using FluentAssertions;
 using Snapshooter.Exceptions;
 using Snapshooter.Tests.Data;
+using Snapshooter.Xunit.Tests.Helpers;
 using Xunit;
 using Xunit.Sdk;
 
@@ -901,6 +903,117 @@ public void Match_FactMatchScalarIntegerValueSnapshot_IgnoreOptionFails()
 
         #endregion
 
+        #region Match Snapshots - Stream Types Tests
+
+        [Fact]
+        public void Match_FactMatchMemoryStreamSnapshot_SuccessfulMatch()
+        {
+            // arrange
+            MemoryStream testMemoryStream =
+                new MemoryStream(Encoding.ASCII.GetBytes("Foo Bar 35"));
+
+            // act & assert
+            Snapshot.Match(testMemoryStream);
+        }
+
+        [Fact]
+        public void Match_FactMatchObjectWithMemoryStreamSnapshot_SuccessfulMatch()
+        {
+            // arrange
+            var testUser = new
+            {
+                FirstName = "Foo",
+                Age = 35,
+                Picture = new MemoryStream(Encoding.ASCII.GetBytes("Foo Bar 35"))
+            };
+
+            // act & assert
+            Snapshot.Match(testUser);
+        }
+
+        [Fact]
+        public void Match_FactMatchStreamSnapshot_SuccessfulMatch()
+        {
+            // arrange
+            Stream testStream =
+                TestFileLoader.LoadFileStream("mona-lisa.jpg");
+
+            // act & assert
+            Snapshot.Match(testStream);
+        }
+
+        [Fact]
+        public void Match_FactMatchObjectWithStreamSnapshot_SuccessfulMatch()
+        {
+            // arrange
+            var testUser = new
+            {
+                FirstName = "Foo",
+                Age = 35,
+                Picture = TestFileLoader.LoadFileStream("mona-lisa.jpg")
+            };
+
+            // act & assert
+            Snapshot.Match(testUser);
+        }
+
+        [Fact]
+        public void Match_FactMatchFileStreamSnapshot_SuccessfulMatch()
+        {
+            // arrange
+            string folderPath = SnapshotDefaultNameResolver
+                .ResolveSnapshotDefaultFullName()
+                .FolderPath;
+
+            Stream testStream = 
+                File.OpenRead($"{folderPath}/__testsources__/mona-lisa.jpg");
+
+            // act & assert
+            Snapshot.Match(testStream);
+        }
+
+        [Fact]
+        public void Match_FactMatchObjectWithFileStreamSnapshot_SuccessfulMatch()
+        {
+            // arrange
+            string folderPath = SnapshotDefaultNameResolver
+                .ResolveSnapshotDefaultFullName()
+                .FolderPath;
+
+            var testUser = new
+            {
+                FirstName = "Foo",
+                Age = 35,
+                Picture = File.OpenRead($"{folderPath}/__testsources__/mona-lisa.jpg")
+            };
+
+            // act & assert
+            Snapshot.Match(testUser);
+        }
+
+        [Fact]
+        public void Match_FactMatchObjectWithAllStreamsSnapshot_SuccessfulMatch()
+        {
+            // arrange
+            string folderPath = SnapshotDefaultNameResolver
+                .ResolveSnapshotDefaultFullName()
+                .FolderPath;
+
+            var testUser = new
+            {
+                FirstName = "Foo",
+                Age = 35,
+                MemoryStreamName = new MemoryStream(Encoding.ASCII.GetBytes("Foo Bar 35")),
+                EmbeddedStreamPicture = TestFileLoader.LoadFileStream("mona-lisa.jpg"),
+                FileStreamPicture = File.OpenRead($"{folderPath}/__testsources__/mona-lisa.jpg")
+            };
+
+            // act & assert
+            Snapshot.Match(testUser);
+        }
+
+        #endregion
+
         #region Match Snapshots - Crlf Tests
 
         [Fact]

test/Snapshooter.Xunit.Tests/__snapshots__/SnapshotTests.Match_FactMatchMemoryStreamSnapshot_SuccessfulMatch.snap

@@ -0,0 +1 @@
+"Rm9vIEJhciAzNQ=="

test/Snapshooter.Xunit.Tests/__snapshots__/SnapshotTests.Match_FactMatchObjectWithMemoryStreamSnapshot_SuccessfulMatch.snap

@@ -0,0 +1,5 @@
+{
+  "FirstName": "Foo",
+  "Age": 35,
+  "Picture": "Rm9vIEJhciAzNQ=="
+}