Fix initial winmerge.bat being added to the wrong test context

C0nquistadore · C0nquistadore · commit 853646d5ae9b · 2025-03-12T09:04:12.000+01:00
diff --git a/src/Dibix.Testing/Utilities/TestMethodTestResultFileComposer.cs b/src/Dibix.Testing/Utilities/TestMethodTestResultFileComposer.cs
@@ -10,11 +10,13 @@ internal sealed class TestMethodTestResultFileComposer : TestResultFileComposer
     {
         private readonly string _resultTestsDirectory;
         private readonly string _normalizedTestName;
+        private readonly TestContext _testContext;
 
-        private TestMethodTestResultFileComposer(string directory, string resultTestsDirectory, string normalizedTestName, TestContext testContext) : base(directory, testContext)
+        private TestMethodTestResultFileComposer(string directory, string resultTestsDirectory, string normalizedTestName, TestContext testContext) : base(directory)
         {
             _resultTestsDirectory = resultTestsDirectory;
             _normalizedTestName = normalizedTestName;
+            _testContext = testContext;
         }
 
         public static TestMethodTestResultFileComposer Create(TestContext testContext, string resultTestsDirectory)
@@ -40,5 +42,13 @@ public void ZipTestOutput(string resultRunDirectory, IEnumerable<string> resultF
             }
             RegisterResultFile(path);
         }
+
+        public string AddResultFile(string fileName) => AddResultFile(fileName, _testContext);
+
+        public string AddResultFile(string fileName, string content) => AddResultFile(fileName, content, _testContext);
+
+        public string ImportResultFile(string filePath) => ImportResultFile(filePath, _testContext);
+
+        public void RegisterResultFile(string path) => RegisterResultFile(path, _testContext);
     }
 }
diff --git a/src/Dibix.Testing/Utilities/TestResultComposer.cs b/src/Dibix.Testing/Utilities/TestResultComposer.cs
@@ -7,43 +7,40 @@ namespace Dibix.Testing
 {
     public abstract class TestResultFileComposer
     {
-        private readonly TestContext _testContext;
-        
         public ICollection<string> ResultFiles { get; }
         public string ResultDirectory { get; }
 
-        protected TestResultFileComposer(string directory, TestContext testContext)
+        protected TestResultFileComposer(string directory)
         {
             ResultDirectory = directory;
             ResultFiles = new List<string>();
-            _testContext = testContext;
         }
 
-        public string AddResultFile(string fileName)
+        public string AddResultFile(string fileName, TestContext testContext)
         {
             string path = Path.Combine(ResultDirectory, fileName);
             EnsureDirectory(path);
-            RegisterResultFile(path);
+            RegisterResultFile(path, testContext);
             OnFileNameRegistered(fileName);
             return path;
         }
 
-        public string AddResultFile(string fileName, string content)
+        public string AddResultFile(string fileName, string content, TestContext testContext)
         {
-            string path = AddResultFile(fileName);
+            string path = AddResultFile(fileName, testContext);
             WriteContentToFile(path, content);
             return path;
         }
 
-        public string ImportResultFile(string filePath)
+        public string ImportResultFile(string filePath, TestContext testContext)
         {
             string fileName = Path.GetFileName(filePath);
-            string targetPath = AddResultFile(fileName);
+            string targetPath = AddResultFile(fileName, testContext);
             File.Copy(filePath, targetPath);
             return targetPath;
         }
 
-        public void RegisterResultFile(string path)
+        public void RegisterResultFile(string path, TestContext testContext)
         {
             if (path.Length > 255)
             {
@@ -57,7 +54,7 @@ public void RegisterResultFile(string path)
                 throw new InvalidOperationException($"Test result file already registered: {path}");
 
             ResultFiles.Add(path);
-            _testContext.AddResultFile(path);
+            testContext.AddResultFile(path);
         }
 
         public static void WriteContentToFile(string path, string content)
diff --git a/src/Dibix.Testing/Utilities/TestResultFileManager.cs b/src/Dibix.Testing/Utilities/TestResultFileManager.cs
@@ -13,17 +13,19 @@ internal sealed class TestResultFileManager
         private readonly TestRunTestResultFileComposer _testRunFileComposer;
         private readonly TestMethodTestResultFileComposer _testMethodFileComposer;
         private readonly WinMergeComparisonComposer _winMergeComparisonComposer;
+        private readonly TestContext _testContext;
         private readonly TestClassInstanceScope _scope;
         private bool _eventLogCollected;
 
         public string RunDirectory => _testRunFileComposer.ResultDirectory;
         public string TestDirectory => _testMethodFileComposer.ResultDirectory;
 
-        private TestResultFileManager(TestRunTestResultFileComposer testRunFileComposer, TestMethodTestResultFileComposer testMethodFileComposer, WinMergeComparisonComposer winMergeComparisonComposer, TestClassInstanceScope scope)
+        private TestResultFileManager(TestRunTestResultFileComposer testRunFileComposer, TestMethodTestResultFileComposer testMethodFileComposer, WinMergeComparisonComposer winMergeComparisonComposer, TestContext testContext, TestClassInstanceScope scope)
         {
             _testRunFileComposer = testRunFileComposer;
             _testMethodFileComposer = testMethodFileComposer;
             _winMergeComparisonComposer = winMergeComparisonComposer;
+            _testContext = testContext;
             _scope = scope;
         }
 
@@ -32,8 +34,8 @@ public static TestResultFileManager FromTestContext(TestContext testContext, boo
             TestRunTestResultFileComposer testRunFileComposer = TestRunTestResultFileComposer.Resolve(testContext, useDedicatedTestResultsDirectory);
             string resultTestsDirectory = Path.Combine(testRunFileComposer.ResultDirectory, "Tests");
             TestMethodTestResultFileComposer testMethodFileComposer = TestMethodTestResultFileComposer.Create(testContext, resultTestsDirectory);
-            WinMergeComparisonComposer winMergeComparisonComposer = new WinMergeComparisonComposer(testMethodFileComposer, testRunFileComposer);
-            TestResultFileManager resultFileComposer = new TestResultFileManager(testRunFileComposer, testMethodFileComposer, winMergeComparisonComposer, scope);
+            WinMergeComparisonComposer winMergeComparisonComposer = new WinMergeComparisonComposer(testMethodFileComposer, testRunFileComposer, testContext);
+            TestResultFileManager resultFileComposer = new TestResultFileManager(testRunFileComposer, testMethodFileComposer, winMergeComparisonComposer, testContext, scope);
             return resultFileComposer;
         }
 
@@ -49,10 +51,10 @@ public string AddTestFile(string fileName)
 
         public string ImportTestFile(string filePath) => _testMethodFileComposer.ImportResultFile(filePath);
 
-        public string AddTestRunFile(string fileName) => _testRunFileComposer.AddResultFile(fileName);
-        public string AddTestRunFile(string fileName, string content) => _testRunFileComposer.AddResultFile(fileName, content);
+        public string AddTestRunFile(string fileName) => _testRunFileComposer.AddResultFile(fileName, _testContext);
+        public string AddTestRunFile(string fileName, string content) => _testRunFileComposer.AddResultFile(fileName, content, _testContext);
 
-        public string ImportTestRunFile(string filePath) => _testRunFileComposer.ImportResultFile(filePath);
+        public string ImportTestRunFile(string filePath) => _testRunFileComposer.ImportResultFile(filePath, _testContext);
 
         public void AddFileComparison(string expectedContent, string actualContent, string outputName, string extension) => _winMergeComparisonComposer.AddFileComparison(expectedContent, actualContent, outputName, extension);
 
@@ -91,7 +93,7 @@ string FormatContent(EventLogEntry entry)
 
             TestResultFileComposer composer = GetTargetTestResultFileComposer(_scope);
 
-            composer.AddResultFile("EventLogOptions.json", JsonConvert.SerializeObject(options, Formatting.Indented));
+            composer.AddResultFile("EventLogOptions.json", JsonConvert.SerializeObject(options, Formatting.Indented), _testContext);
 
             EventLog eventLog = new EventLog(options.LogName, options.MachineName, options.Source);
 
@@ -100,7 +102,7 @@ string FormatContent(EventLogEntry entry)
                       .Select(x => eventLog.Entries[x])
                       .Where(x => MatchEventLogEntry(x, options.Type, options.Since))
                       .Take(options.Count)
-                      .Each((x, i) => composer.AddResultFile($"EventLogEntry_{i + 1}_{x.EntryType}.txt", FormatContent(x)));
+                      .Each((x, i) => composer.AddResultFile($"EventLogEntry_{i + 1}_{x.EntryType}.txt", FormatContent(x), _testContext));
         }
 
         private TestResultFileComposer GetTargetTestResultFileComposer(TestClassInstanceScope scope) => scope switch
diff --git a/src/Dibix.Testing/Utilities/TestRunTestResultFileComposer.cs b/src/Dibix.Testing/Utilities/TestRunTestResultFileComposer.cs
@@ -15,15 +15,13 @@ namespace Dibix.Testing
     internal sealed class TestRunTestResultFileComposer : TestResultFileComposer
     {
         private static readonly ConcurrentDictionary<string, Lazy<TestRunTestResultFileComposer>> Cache = new ConcurrentDictionary<string, Lazy<TestRunTestResultFileComposer>>();
-        private readonly TestContext _testContext;
         private readonly string _defaultRunDirectory;
         private readonly bool _useDedicatedTestResultsDirectory;
         private readonly ICollection<string> _deployedFiles;
         private readonly ICollection<string> _registeredFileNames;
 
-        private TestRunTestResultFileComposer(string directory, TestContext testContext, string defaultRunDirectory, bool useDedicatedTestResultsDirectory) : base(directory, testContext)
+        private TestRunTestResultFileComposer(string directory, string defaultRunDirectory, bool useDedicatedTestResultsDirectory) : base(directory)
         {
-            _testContext = testContext;
             _defaultRunDirectory = defaultRunDirectory;
             _deployedFiles = new HashSet<string>();
             _useDedicatedTestResultsDirectory = useDedicatedTestResultsDirectory;
@@ -36,10 +34,13 @@ public static TestRunTestResultFileComposer Resolve(TestContext testContext, boo
             string testRunIdentifier = testContext.TestRunDirectory;
 
             // Use Lazy<T> to ensure the test run attachments are only written to disk once when running tests in parallel
-            TestRunTestResultFileComposer instance = Cache.GetOrAdd(testRunIdentifier, _ => new Lazy<TestRunTestResultFileComposer>(() => Create(testContext, useDedicatedTestResultsDirectory))).Value;
+            Lazy<TestRunTestResultFileComposer> value = Cache.GetOrAdd(testRunIdentifier, _ => new Lazy<TestRunTestResultFileComposer>(() => Create(testContext, useDedicatedTestResultsDirectory)));
+            bool isFirstTest = !value.IsValueCreated;
+            TestRunTestResultFileComposer instance = value.Value;
 
             // Make test run attachments available for each test method
-            instance.ImportResultFilesIfNecessary(testContext);
+            if (!isFirstTest)
+                instance.ImportResultFiles(testContext);
 
             return instance;
         }
@@ -56,28 +57,25 @@ public void CopyTestOutput(IEnumerable<string> resultFiles)
 
         protected override void OnFileNameRegistered(string fileName) => _registeredFileNames.Add(fileName);
 
-        private void Initialize()
+        private void Initialize(TestContext testContext)
         {
-            EnsureTestContextDump();
-            EnsureEnvironmentDump();
+            EnsureTestContextDump(testContext);
+            EnsureEnvironmentDump(testContext);
         }
 
-        private void ImportResultFilesIfNecessary(TestContext currentTestContext)
+        private void ImportResultFiles(TestContext testContext)
         {
-            if (currentTestContext == _testContext)
-                return;
-
             foreach (string resultFile in ResultFiles)
-                currentTestContext.AddResultFile(resultFile);
+                testContext.AddResultFile(resultFile);
         }
 
-        private void EnsureTestContextDump() => AddResultFile("TestContext.json", JsonConvert.SerializeObject(_testContext, new JsonSerializerSettings
+        private void EnsureTestContextDump(TestContext testContext) => AddResultFile("TestContext.json", JsonConvert.SerializeObject(testContext, new JsonSerializerSettings
         {
             Formatting = Formatting.Indented,
             ContractResolver = new TestContextContractResolver()
-        }));
+        }), testContext);
 
-        private void EnsureEnvironmentDump()
+        private void EnsureEnvironmentDump(TestContext testContext)
         {
             IDictionary<string, object> environmentVariables = Environment.GetEnvironmentVariables()
                                                                           .Cast<DictionaryEntry>()
@@ -94,7 +92,7 @@ private void EnsureEnvironmentDump()
             }
 
             string environment = sb.ToString();
-            AddResultFile("Environment.txt", environment);
+            AddResultFile("Environment.txt", environment, testContext);
         }
 
         private void CopyFiles(IEnumerable<string> files, string targetDirectory)
@@ -120,8 +118,8 @@ private static TestRunTestResultFileComposer Create(TestContext testContext, boo
         {
             string defaultRunDirectory = testContext.TestRunResultsDirectory;
             string runDirectory = useDedicatedTestResultsDirectory ? CreateTestRunDirectory(testContext) : defaultRunDirectory;
-            TestRunTestResultFileComposer instance = new TestRunTestResultFileComposer(runDirectory, testContext, defaultRunDirectory, useDedicatedTestResultsDirectory);
-            instance.Initialize();
+            TestRunTestResultFileComposer instance = new TestRunTestResultFileComposer(runDirectory, defaultRunDirectory, useDedicatedTestResultsDirectory);
+            instance.Initialize(testContext);
             return instance;
         }
 
diff --git a/src/Dibix.Testing/Utilities/WinMergeComparisonComposer.cs b/src/Dibix.Testing/Utilities/WinMergeComparisonComposer.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.IO;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace Dibix.Testing
 {
@@ -10,13 +11,15 @@ internal class WinMergeComparisonComposer
         private const string ActualDirectoryName = "actual";
         private readonly TestMethodTestResultFileComposer _testMethodFileComposer;
         private readonly TestRunTestResultFileComposer _testRunFileComposer;
+        private readonly TestContext _testContext;
         private readonly string _expectedDirectory;
         private readonly string _actualDirectory;
 
-        public WinMergeComparisonComposer(TestMethodTestResultFileComposer testMethodFileComposer, TestRunTestResultFileComposer testRunFileComposer)
+        public WinMergeComparisonComposer(TestMethodTestResultFileComposer testMethodFileComposer, TestRunTestResultFileComposer testRunFileComposer, TestContext testContext)
         {
             _testMethodFileComposer = testMethodFileComposer;
             _testRunFileComposer = testRunFileComposer;
+            _testContext = testContext;
             _expectedDirectory = Path.Combine(testRunFileComposer.ResultDirectory, ExpectedDirectoryName);
             _actualDirectory = Path.Combine(testRunFileComposer.ResultDirectory, ActualDirectoryName);
         }
@@ -37,9 +40,9 @@ private void EnsureWinMergeStarter()
                     return;
 
                 _testRunFileComposer.AddResultFile(fileName, $"""
-                                                                 @echo off
-                                                                 start winmergeU "{ExpectedDirectoryName}" "{ActualDirectoryName}"
-                                                                 """);
+                                                              @echo off
+                                                              start winmergeU "{ExpectedDirectoryName}" "{ActualDirectoryName}"
+                                                              """, _testContext);
             }
         }
 
@@ -61,7 +64,7 @@ private void EnsureFileComparisonContent(string path, string outputName, string
         private void EnsureFileComparisonContent(string path, string content)
         {
             TestResultFileComposer.WriteContentToFile(path, content);
-            _testMethodFileComposer.RegisterResultFile(path);
+            _testMethodFileComposer.RegisterResultFile(path, _testContext);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -10,11 +10,13 @@ internal sealed class TestMethodTestResultFileComposer : TestResultFileComposer`
`10`	`10`	`{`
`11`	`11`	`private readonly string _resultTestsDirectory;`
`12`	`12`	`private readonly string _normalizedTestName;`
	`13`	`+ private readonly TestContext _testContext;`
`13`	`14`
`14`		`- private TestMethodTestResultFileComposer(string directory, string resultTestsDirectory, string normalizedTestName, TestContext testContext) : base(directory, testContext)`
	`15`	`+ private TestMethodTestResultFileComposer(string directory, string resultTestsDirectory, string normalizedTestName, TestContext testContext) : base(directory)`
`15`	`16`	`{`
`16`	`17`	`_resultTestsDirectory = resultTestsDirectory;`
`17`	`18`	`_normalizedTestName = normalizedTestName;`
	`19`	`+ _testContext = testContext;`
`18`	`20`	`}`
`19`	`21`
`20`	`22`	`public static TestMethodTestResultFileComposer Create(TestContext testContext, string resultTestsDirectory)`
`@@ -40,5 +42,13 @@ public void ZipTestOutput(string resultRunDirectory, IEnumerable<string> resultF`
`40`	`42`	`}`
`41`	`43`	`RegisterResultFile(path);`
`42`	`44`	`}`
	`45`	`+`
	`46`	`+ public string AddResultFile(string fileName) => AddResultFile(fileName, _testContext);`
	`47`	`+`
	`48`	`+ public string AddResultFile(string fileName, string content) => AddResultFile(fileName, content, _testContext);`
	`49`	`+`
	`50`	`+ public string ImportResultFile(string filePath) => ImportResultFile(filePath, _testContext);`
	`51`	`+`
	`52`	`+ public void RegisterResultFile(string path) => RegisterResultFile(path, _testContext);`
`43`	`53`	`}`
`44`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,43 +7,40 @@ namespace Dibix.Testing`
`7`	`7`	`{`
`8`	`8`	`public abstract class TestResultFileComposer`
`9`	`9`	`{`
`10`		`- private readonly TestContext _testContext;`
`11`		`-`
`12`	`10`	`public ICollection<string> ResultFiles { get; }`
`13`	`11`	`public string ResultDirectory { get; }`
`14`	`12`
`15`		`- protected TestResultFileComposer(string directory, TestContext testContext)`
	`13`	`+ protected TestResultFileComposer(string directory)`
`16`	`14`	`{`
`17`	`15`	`ResultDirectory = directory;`
`18`	`16`	`ResultFiles = new List<string>();`
`19`		`- _testContext = testContext;`
`20`	`17`	`}`
`21`	`18`
`22`		`- public string AddResultFile(string fileName)`
	`19`	`+ public string AddResultFile(string fileName, TestContext testContext)`
`23`	`20`	`{`
`24`	`21`	`string path = Path.Combine(ResultDirectory, fileName);`
`25`	`22`	`EnsureDirectory(path);`
`26`		`- RegisterResultFile(path);`
	`23`	`+ RegisterResultFile(path, testContext);`
`27`	`24`	`OnFileNameRegistered(fileName);`
`28`	`25`	`return path;`
`29`	`26`	`}`
`30`	`27`
`31`		`- public string AddResultFile(string fileName, string content)`
	`28`	`+ public string AddResultFile(string fileName, string content, TestContext testContext)`
`32`	`29`	`{`
`33`		`- string path = AddResultFile(fileName);`
	`30`	`+ string path = AddResultFile(fileName, testContext);`
`34`	`31`	`WriteContentToFile(path, content);`
`35`	`32`	`return path;`
`36`	`33`	`}`
`37`	`34`
`38`		`- public string ImportResultFile(string filePath)`
	`35`	`+ public string ImportResultFile(string filePath, TestContext testContext)`
`39`	`36`	`{`
`40`	`37`	`string fileName = Path.GetFileName(filePath);`
`41`		`- string targetPath = AddResultFile(fileName);`
	`38`	`+ string targetPath = AddResultFile(fileName, testContext);`
`42`	`39`	`File.Copy(filePath, targetPath);`
`43`	`40`	`return targetPath;`
`44`	`41`	`}`
`45`	`42`
`46`		`- public void RegisterResultFile(string path)`
	`43`	`+ public void RegisterResultFile(string path, TestContext testContext)`
`47`	`44`	`{`
`48`	`45`	`if (path.Length > 255)`
`49`	`46`	`{`
`@@ -57,7 +54,7 @@ public void RegisterResultFile(string path)`
`57`	`54`	`throw new InvalidOperationException($"Test result file already registered: {path}");`
`58`	`55`
`59`	`56`	`ResultFiles.Add(path);`
`60`		`- _testContext.AddResultFile(path);`
	`57`	`+ testContext.AddResultFile(path);`
`61`	`58`	`}`
`62`	`59`
`63`	`60`	`public static void WriteContentToFile(string path, string content)`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.IO;`
	`3`	`+using Microsoft.VisualStudio.TestTools.UnitTesting;`
`3`	`4`
`4`	`5`	`namespace Dibix.Testing`
`5`	`6`	`{`
`@@ -10,13 +11,15 @@ internal class WinMergeComparisonComposer`
`10`	`11`	`private const string ActualDirectoryName = "actual";`
`11`	`12`	`private readonly TestMethodTestResultFileComposer _testMethodFileComposer;`
`12`	`13`	`private readonly TestRunTestResultFileComposer _testRunFileComposer;`
	`14`	`+ private readonly TestContext _testContext;`
`13`	`15`	`private readonly string _expectedDirectory;`
`14`	`16`	`private readonly string _actualDirectory;`
`15`	`17`
`16`		`- public WinMergeComparisonComposer(TestMethodTestResultFileComposer testMethodFileComposer, TestRunTestResultFileComposer testRunFileComposer)`
	`18`	`+ public WinMergeComparisonComposer(TestMethodTestResultFileComposer testMethodFileComposer, TestRunTestResultFileComposer testRunFileComposer, TestContext testContext)`
`17`	`19`	`{`
`18`	`20`	`_testMethodFileComposer = testMethodFileComposer;`
`19`	`21`	`_testRunFileComposer = testRunFileComposer;`
	`22`	`+ _testContext = testContext;`
`20`	`23`	`_expectedDirectory = Path.Combine(testRunFileComposer.ResultDirectory, ExpectedDirectoryName);`
`21`	`24`	`_actualDirectory = Path.Combine(testRunFileComposer.ResultDirectory, ActualDirectoryName);`
`22`	`25`	`}`
`@@ -37,9 +40,9 @@ private void EnsureWinMergeStarter()`
`37`	`40`	`return;`
`38`	`41`
`39`	`42`	`_testRunFileComposer.AddResultFile(fileName, $"""`
`40`		`- @echo off`
`41`		`- start winmergeU "{ExpectedDirectoryName}" "{ActualDirectoryName}"`
`42`		`- """);`
	`43`	`+ @echo off`
	`44`	`+ start winmergeU "{ExpectedDirectoryName}" "{ActualDirectoryName}"`
	`45`	`+ """, _testContext);`
`43`	`46`	`}`
`44`	`47`	`}`
`45`	`48`
`@@ -61,7 +64,7 @@ private void EnsureFileComparisonContent(string path, string outputName, string`
`61`	`64`	`private void EnsureFileComparisonContent(string path, string content)`
`62`	`65`	`{`
`63`	`66`	`TestResultFileComposer.WriteContentToFile(path, content);`
`64`		`- _testMethodFileComposer.RegisterResultFile(path);`
	`67`	`+ _testMethodFileComposer.RegisterResultFile(path, _testContext);`
`65`	`68`	`}`
`66`	`69`	`}`
`67`	`70`	`}`