Merge pull request #1 from Michal-MK/feat/add-binary-comparison

exyi · web-flow · commit 667a421111ff · 2023-01-27T14:08:56.000Z
Feat/add binary comparison
diff --git a/exampleTest/BinaryTest.cs b/exampleTest/BinaryTest.cs
@@ -0,0 +1,64 @@
+﻿using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Xunit;
+
+namespace CheckTestOutput.Example
+{
+    public class BinaryTest
+    {
+        private const string ImagePath = "Image.png";
+
+        OutputChecker check = new OutputChecker("testoutputs");
+
+        [Fact]
+        public void CheckStagedBinaryData()
+        {
+            check.CheckBinary(File.ReadAllBytes(Path.Combine(check.CheckDirectory, ImagePath)));
+            Assert.True(true);
+        }
+
+        [Fact]
+        public void CheckModifiedBinaryData()
+        {
+            var imgPath = Path.Combine(check.CheckDirectory, ImagePath);
+            byte[] previousData = File.ReadAllBytes(imgPath);
+            byte[] modifiedData = previousData.Append((byte)64).ToArray();
+
+            // File contents do not match
+            Assert.Throws<Exception>(() => check.CheckBinary(modifiedData));
+
+            // Return back the original content
+            File.WriteAllBytes(Path.Combine(check.CheckDirectory, $"{nameof(BinaryTest)}.{nameof(CheckModifiedBinaryData)}.bin"), previousData);
+        }
+
+        [Fact]
+        public void CheckNonexistentBinaryData()
+        {
+            var imageBytes = File.ReadAllBytes(Path.Combine(check.CheckDirectory, ImagePath));
+            // File does not exist
+            Assert.Throws<ArgumentNullException>(() => check.CheckBinary(imageBytes));
+        }
+        
+        [Fact]
+        public void CheckUTF8TextConvertedToBinaryData()
+        {
+            const string TEXT = "( ͡° ͜ʖ ͡°)";
+
+            check.CheckBinary(Encoding.UTF8.GetBytes(TEXT));
+            Assert.True(true);
+        }   
+        
+        [Fact]
+        public void CheckUTF8TextConvertedWithASCIIBinaryDataThrows()
+        {
+            const string TEXT = "( ͡° ͜ʖ ͡°)";
+
+            Assert.Throws<Exception>(() => check.CheckBinary(Encoding.ASCII.GetBytes(TEXT)));
+            
+            // Return back the original content
+            File.WriteAllBytes(Path.Combine(check.CheckDirectory, $"{nameof(BinaryTest)}.{nameof(CheckUTF8TextConvertedWithASCIIBinaryDataThrows)}.bin"), Encoding.UTF8.GetBytes(TEXT));
+        }
+    }
+}
diff --git a/exampleTest/testoutputs/BinaryTest.CheckModifiedBinaryData.bin b/exampleTest/testoutputs/BinaryTest.CheckModifiedBinaryData.bin
diff --git a/exampleTest/testoutputs/BinaryTest.CheckStagedBinaryData.bin b/exampleTest/testoutputs/BinaryTest.CheckStagedBinaryData.bin
diff --git a/exampleTest/testoutputs/BinaryTest.CheckUTF8TextConvertedToBinaryData.bin b/exampleTest/testoutputs/BinaryTest.CheckUTF8TextConvertedToBinaryData.bin
@@ -0,0 +1 @@
+( ͡° ͜ʖ ͡°)
diff --git a/exampleTest/testoutputs/BinaryTest.CheckUTF8TextConvertedWithASCIIBinaryDataThrows.bin b/exampleTest/testoutputs/BinaryTest.CheckUTF8TextConvertedWithASCIIBinaryDataThrows.bin
@@ -0,0 +1 @@
+( ͡° ͜ʖ ͡°)
diff --git a/exampleTest/testoutputs/Image.png b/exampleTest/testoutputs/Image.png
diff --git a/src/BasicChecks.cs b/src/BasicChecks.cs
@@ -1,7 +1,5 @@
-using System;
-using System.Collections.Generic;
+﻿using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 
 namespace CheckTestOutput
 {
@@ -25,6 +23,24 @@ public static void CheckString(
             );
         }
 
+        /// <summary> Verifies that the provided <paramref name="output" /> equals to the `outputDirectory/TestClass.TestMethod.bin` file. </summary>
+        /// <param name="checkName"> If not null, checkName will be appended to the calling <paramref name="memberName" />. Intended to be used when having multiple checks in one method. </param>
+        public static void CheckBinary(
+            this OutputChecker t,
+            byte[] output,
+            string checkName = null,
+            string fileExtension = "bin",
+            [System.Runtime.CompilerServices.CallerMemberName] string memberName = null,
+            [System.Runtime.CompilerServices.CallerFilePath] string sourceFilePath = null)
+        {
+            t.CheckOutputBinaryCore(
+                output,
+                checkName,
+                $"{Path.GetFileNameWithoutExtension(sourceFilePath)}.{memberName}",
+                fileExtension
+            );
+        }
+
         /// <summary> Verifies that the provided <paramref name="output" /> equals to the `outputDirectory/TestClass.TestMethod.txt` file. File is compared line-by-line. </summary>
         /// <param name="checkName"> If not null, checkName will be appended to the calling <paramref name="memberName" />. Intended to be used when having multiple checks in one method. </param>
         public static void CheckLines(
diff --git a/src/CheckTestOutput.csproj b/src/CheckTestOutput.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.1;net6.0;net7.0</TargetFrameworks>
     <LangVersion>9</LangVersion>
 
     <Description>Simple helper which checks that output of a test matches a file. If not matching, just git staging the new file will accept the new version.</Description>
diff --git a/src/OutputChecker.cs b/src/OutputChecker.cs
@@ -1,4 +1,4 @@
-using System;
+﻿using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.ComponentModel;
@@ -83,7 +83,7 @@ public OutputChecker(
 
         private readonly Lazy<bool> DoesGitWork;
 
-        private string[] RunGitCommand(params string[] args)
+        private Process StartGitProcess(params string[] args)
         {
 #if DEBUG
             Console.WriteLine("Running git command: " + string.Join(" ", args));
@@ -104,18 +104,11 @@ private string[] RunGitCommand(params string[] args)
                 procInfo.ArgumentList.Add(a);
 
 
-            var proc = Process.Start(procInfo);
-
-            var outputLines = new List<string>();
-            var outputReaderTask = Task.Run(() => {
-                string line = null;
-                while ((line = proc.StandardOutput.ReadLine()) != null)
-                {
-                    if (line.Length > 0)
-                        outputLines.Add(line);
-                }
-            });
+            return Process.Start(procInfo);
+        }
 
+        private void HandleProcessExit(Process proc, Task outputReaderTask, params string[] args)
+        {
             // Literally, a Raspberry PI with a shitty SD card has faster IO than Azure Windows VM
             var timeout = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? 15_000 : 3_000;
             if (!proc.WaitForExit(timeout))
@@ -128,10 +121,52 @@ private string[] RunGitCommand(params string[] args)
                 throw new Exception($"`git {string.Join(" ", args)}` command failed: " + proc.StandardError.ReadToEnd());
 
             outputReaderTask.Wait();
+        }
+
+        private string[] RunGitCommand(params string[] args)
+        {
+            var proc = StartGitProcess(args);
+
+            var outputLines = new List<string>();
+            var outputReaderTask = Task.Run(() =>
+            {
+                string line;
+                while ((line = proc.StandardOutput.ReadLine()) != null)
+                {
+                    if (line.Length > 0)
+                        outputLines.Add(line);
+                }
+            });
+
+            HandleProcessExit(proc, outputReaderTask, args);
 
             return outputLines.ToArray();
         }
 
+        private byte[] RunGitBinaryCommand(params string[] args)
+        {
+            const int BUFFER_SIZE = 1024;
+
+            var proc = StartGitProcess(args);
+
+            List<byte> ret = new();
+
+            var outputReaderTask = Task.Run(() =>
+            {
+                byte[] buffer = new byte[BUFFER_SIZE];
+
+                int charsRead = 0;
+                while ((charsRead = proc.StandardOutput.BaseStream.Read(buffer, 0, BUFFER_SIZE)) != 0)
+                {
+                    ret.AddRange(buffer.AsSpan(0, charsRead).ToArray());
+                }
+            });
+
+            HandleProcessExit(proc, outputReaderTask, args);
+
+            return ret.ToArray();
+        }
+
         static string[] ReadAllLines(StreamReader reader)
         {
             var lines = new List<string>();
@@ -160,6 +195,28 @@ private string GetOldContent(string file)
             }
         }
 
+        private byte[] GetOldBinaryContent(string file)
+        {
+            if (DoesGitWork.Value)
+            {
+                var lsFiles = RunGitCommand("ls-files", "-s", file);
+                if (lsFiles.Length == 0)
+                    return null;
+
+                var hash = lsFiles[0].Split(new[] { '\t', ' ' }, StringSplitOptions.RemoveEmptyEntries).ElementAtOrDefault(1);
+                if (String.IsNullOrEmpty(hash))
+                    return null;
+
+                var data = RunGitBinaryCommand("cat-file", "blob", hash);
+
+                return data;
+            }
+            else
+            {
+                return File.ReadAllBytes(file);
+            }
+        }
+
         private bool IsModified(string file)
         {
             // command `git ls-files --other --modified $file` returns the file name back iff it is modified or other (untracked)
@@ -242,14 +299,67 @@ internal void CheckOutputCore(string outputString, string checkName, string meth
                     throw new Exception(
                         $"{Path.GetFileName(filename)} has changed, the actual output differs from the previous accepted output:\n\n" +
                         string.Join("\n", diff) + "\n\n" +
-                        "If this change OK? To let the test pass, stage the file in git. Confused? See https://github.com/exyi/CheckTestOutput/blob/master/trouble.md#changed-file\n"
+                        "Is this change OK? To let the test pass, stage the file in git. Confused? See https://github.com/exyi/CheckTestOutput/blob/master/trouble.md#changed-file\n"
+
+                    );
+                }
+            }
+            else
+            {
+                throw new Exception($"{Path.GetFileName(filename)} has changed, the previous accepted output differs from the actual output:\n\n{outputString}\n\nNote that CheckTestOutput could not use git on your system, so the \"UX\" is limited.");
+            }
+        }
+
+        internal void CheckOutputBinaryCore(byte[] outputBytes, string checkName, string method, string fileExtension = "bin")
+        {
+            Directory.CreateDirectory(CheckDirectory);
+
+            var filename = Path.Combine(CheckDirectory, (checkName == null ? method : $"{method}-{checkName}") + "." + fileExtension);
 
+            if (GetOldBinaryContent(filename).SequenceEqual(outputBytes))
+            {
+                // fine! Just check that the file is not changed - if it is changed or deleted, we rewrite
+                if (IsModified(filename))
+                {
+                    using (var t = File.Create(filename))
+                    {
+                        t.Write(outputBytes);
+                    }
+                }
+                return;
+            }
+
+            if (DoesGitWork.Value)
+            {
+                using (var t = File.Create(filename))
+                {
+                    t.Write(outputBytes);
+                }
+
+                if (IsModified(filename))
+                {
+                    if (IsNewFile(filename))
+                    {
+                        throw new Exception($"{Path.GetFileName(filename)} is not explicitly accepted - the file is untracked in git. To let this test pass, view the file and stage it. Confused? See https://github.com/exyi/CheckTestOutput/blob/master/trouble.md#untracked-file\n");
+                    }
+
+
+                    var diff = RunGitCommand("diff", filename);
+                    if (diff.All(string.IsNullOrEmpty))
+                    {
+                        // I guess fine from our perspective, but it's weird...
+                        Console.WriteLine($"CheckTestOutput warning: {Path.GetFileName(filename)} is modified, but the diff is empty.");
+                        return;
+                    }
+                    throw new Exception(
+                        $"{Path.GetFileName(filename)} has changed, the actual output differs from the previous accepted output!"
+                        + "Is the change OK? To let the test pass, stage the file in git. Confused? See https://github.com/exyi/CheckTestOutput/blob/master/trouble.md#changed-file\n"
                     );
                 }
             }
             else
             {
-                throw new Exception($"{Path.GetFileName(filename)}has changed, the previous accepted output differs from the actual output:\n\n{outputString}\n\nNote that CheckTestOutput could not use git on your system, so the \"UX\" is limited.");
+                throw new Exception($"{Path.GetFileName(filename)} has changed, the previous accepted output differs from the actual output.");
             }
         }
     }
