Merge pull request #735 from StealthyDeveloper/master

GrahamTheCoder · web-flow · commit 5906b534e475 · 2021-06-14T09:31:25.000+01:00
Fix failing Multifile tests on build server
diff --git a/CodeConverter/Shared/ProjectConversion.cs b/CodeConverter/Shared/ProjectConversion.cs
@@ -10,11 +10,10 @@
 using ICSharpCode.CodeConverter.CSharp;
 using ICSharpCode.CodeConverter.Util;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+
 namespace ICSharpCode.CodeConverter.Shared
 {
-    using System.IO.Abstractions;
-    using Microsoft.CodeAnalysis.Text;
-
     public class ProjectConversion
     {
         private readonly IProjectContentsConverter _projectContentsConverter;
@@ -82,7 +81,8 @@ private static ConversionResult GetSingleResultForDocument(ConversionResult[] co
         }
 
         public static async IAsyncEnumerable<ConversionResult> ConvertProject(Project project,
-            ILanguageConversion languageConversion, IProgress<ConversionProgress> progress,
+            ILanguageConversion languageConversion, TextReplacementConverter textReplacementConverter,
+            IProgress<ConversionProgress> progress,
             IEnumerable<IAssemblySymbol> assembliesBeingConverted,
             [EnumeratorCancellation] CancellationToken cancellationToken,
             params (string Find, string Replace, bool FirstOnly)[] replacements)
@@ -93,12 +93,14 @@ public static async IAsyncEnumerable<ConversionResult> ConvertProject(Project pr
             var sourceFilePaths = project.Documents.Concat(projectContentsConverter.SourceProject.AdditionalDocuments).Select(d => d.FilePath).ToImmutableHashSet();
             var convertProjectContents = ConvertProjectContents(projectContentsConverter, languageConversion, progress, cancellationToken);
 
-            var results = WithProjectFile(projectContentsConverter, languageConversion, sourceFilePaths, convertProjectContents, replacements);
+            var results = WithProjectFile(projectContentsConverter, textReplacementConverter, languageConversion, sourceFilePaths, convertProjectContents, replacements);
             await foreach (var result in results.WithCancellation(cancellationToken)) yield return result;
         }
 
         /// <remarks>Perf: Keep lazy so that we don't keep an extra copy of all files in memory at once</remarks>
-        private static async IAsyncEnumerable<ConversionResult> WithProjectFile(IProjectContentsConverter projectContentsConverter, ILanguageConversion languageConversion, ImmutableHashSet<string> originalSourcePaths, IAsyncEnumerable<ConversionResult> convertProjectContents, (string Find, string Replace, bool FirstOnly)[] replacements)
+        private static async IAsyncEnumerable<ConversionResult> WithProjectFile(IProjectContentsConverter projectContentsConverter, TextReplacementConverter textReplacementConverter,
+            ILanguageConversion languageConversion, ImmutableHashSet<string> originalSourcePaths,
+            IAsyncEnumerable<ConversionResult> convertProjectContents, (string Find, string Replace, bool FirstOnly)[] replacements)
         {
             var project = projectContentsConverter.SourceProject;
             var projectDir = project.GetDirectoryPath();
@@ -129,14 +131,17 @@ private static async IAsyncEnumerable<ConversionResult> WithProjectFile(IProject
                     ChangeLanguageVersionRegex(projectContentsConverter.LanguageVersion)
                 }).ToArray();
 
-            yield return ConvertProjectFile(project, languageConversion, replacementSpecs);
+            yield return ConvertProjectFile(project, languageConversion, textReplacementConverter, replacementSpecs);
         }
 
         public static ConversionResult ConvertProjectFile(Project project,
             ILanguageConversion languageConversion,
+            TextReplacementConverter textReplacementConverter,
             params (string Find, string Replace, bool FirstOnly)[] textReplacements)
         {
-            return new FileInfo(project.FilePath).ConversionResultFromReplacements(textReplacements,
+            var fileInfo = new FileInfo(project.FilePath);
+
+            return textReplacementConverter.ConversionResultFromReplacements(fileInfo, textReplacements,
                 languageConversion.PostTransformProjectFile);
         }
 
diff --git a/CodeConverter/Shared/SolutionConverter.cs b/CodeConverter/Shared/SolutionConverter.cs
@@ -20,39 +20,34 @@ public class SolutionConverter
         private readonly ILanguageConversion _languageConversion;
         private readonly SolutionFileTextEditor _solutionFileTextEditor;
         private readonly CancellationToken _cancellationToken;
-
-        public static IFileSystem FileSystem { get; set; } = new FileSystem();
-
-        public static SolutionConverter CreateFor<TLanguageConversion>(IReadOnlyCollection<Project> projectsToConvert, string sourceSolutionContents)
-            where TLanguageConversion : ILanguageConversion, new()
-        {
-            return CreateFor<TLanguageConversion>(projectsToConvert, solutionContents: sourceSolutionContents);
-        }
+        private readonly TextReplacementConverter _textReplacementConverter;
 
         public static SolutionConverter CreateFor<TLanguageConversion>(IReadOnlyCollection<Project> projectsToConvert,
             ConversionOptions conversionOptions = default,
             IProgress<ConversionProgress> progress = null,
             CancellationToken cancellationToken = default,
+            IFileSystem fileSystem = null,
             string solutionContents = "") where TLanguageConversion : ILanguageConversion, new()
         {
             var conversion = new TLanguageConversion { ConversionOptions = conversionOptions };
-            return CreateFor(conversion, projectsToConvert, progress, cancellationToken, solutionContents);
+            return CreateFor(conversion, projectsToConvert, progress, cancellationToken, fileSystem, solutionContents);
         }
 
         public static SolutionConverter CreateFor(ILanguageConversion languageConversion, IReadOnlyCollection<Project> projectsToConvert,
-            IProgress<ConversionProgress> progress,
-            CancellationToken cancellationToken, string solutionContents = "")
+            IProgress<ConversionProgress> progress, CancellationToken cancellationToken, IFileSystem fileSystem = null, string solutionContents = "")
         {
             languageConversion.ConversionOptions ??= new ConversionOptions();
+            fileSystem ??= new FileSystem();
+
             var solutionFilePath = projectsToConvert.First().Solution.FilePath;
-            var sourceSolutionContents = File.Exists(solutionFilePath)
-                ? FileSystem.File.ReadAllText(solutionFilePath)
+            var sourceSolutionContents = fileSystem.File.Exists(solutionFilePath)
+                ? fileSystem.File.ReadAllText(solutionFilePath)
                 : solutionContents;
 
             var projTuples = projectsToConvert.Select(proj =>
             {
                 var relativeProjPath = PathConverter.GetRelativePath(solutionFilePath, proj.FilePath);
-                var projContents = FileSystem.File.ReadAllText(proj.FilePath);
+                var projContents = fileSystem.File.ReadAllText(proj.FilePath);
 
                 return (proj.Name, RelativeProjPath: relativeProjPath, ProjContents: projContents);
             });
@@ -61,15 +56,15 @@ public static SolutionConverter CreateFor(ILanguageConversion languageConversion
             var projectReferenceReplacements = solutionFileTextEditor.GetProjectFileProjectReferenceReplacements(projTuples, sourceSolutionContents);
 
             return new SolutionConverter(solutionFilePath, sourceSolutionContents, projectsToConvert, projectReferenceReplacements,
-                progress ?? new Progress<ConversionProgress>(), cancellationToken, languageConversion, solutionFileTextEditor);
+                progress ?? new Progress<ConversionProgress>(), cancellationToken, languageConversion, solutionFileTextEditor, fileSystem);
         }
 
         private SolutionConverter(string solutionFilePath,
             string sourceSolutionContents, IReadOnlyCollection<Project> projectsToConvert,
             List<(string Find, string Replace, bool FirstOnly)> projectReferenceReplacements,
             IProgress<ConversionProgress> showProgressMessage,
             CancellationToken cancellationToken, ILanguageConversion languageConversion,
-            SolutionFileTextEditor solutionFileTextEditor)
+            SolutionFileTextEditor solutionFileTextEditor, IFileSystem fileSystem)
         {
             _solutionFilePath = solutionFilePath;
             _sourceSolutionContents = sourceSolutionContents;
@@ -79,6 +74,7 @@ private SolutionConverter(string solutionFilePath,
             _languageConversion = languageConversion;
             _cancellationToken = cancellationToken;
             _solutionFileTextEditor = solutionFileTextEditor;
+            _textReplacementConverter = new TextReplacementConverter(fileSystem);
         }
 
         public async IAsyncEnumerable<ConversionResult> Convert()
@@ -103,17 +99,20 @@ private IAsyncEnumerable<ConversionResult> ConvertProject(Project project, IEnum
         {
             var replacements = _projectReferenceReplacements.ToArray();
             _progress.Report(new ConversionProgress($"Converting {project.Name}..."));
-            return ProjectConversion.ConvertProject(project, _languageConversion, _progress, assembliesBeingConverted, _cancellationToken, replacements);
+            return ProjectConversion.ConvertProject(project, _languageConversion, _textReplacementConverter, _progress, assembliesBeingConverted, _cancellationToken, replacements);
         }
 
         private IEnumerable<ConversionResult> UpdateProjectReferences(IEnumerable<Project> projectsToUpdateReferencesOnly)
         {
             var conversionResults = projectsToUpdateReferencesOnly
                .Where(p => p.FilePath != null) //Some project types like Websites don't have a project file
                .Select(project => {
-                    var withReferencesReplaced =
-                        new FileInfo(project.FilePath).ConversionResultFromReplacements(_projectReferenceReplacements);
+                    var fileInfo = new FileInfo(project.FilePath);
+
+                    var withReferencesReplaced = 
+                        _textReplacementConverter.ConversionResultFromReplacements(fileInfo, _projectReferenceReplacements);
                     withReferencesReplaced.TargetPathOrNull = withReferencesReplaced.SourcePathOrNull;
+
                     return withReferencesReplaced;
                 });
 
@@ -129,7 +128,7 @@ public ConversionResult ConvertSolutionFile()
             var slnProjectReferenceReplacements = _solutionFileTextEditor.GetSolutionFileProjectReferenceReplacements(relativeProjPaths,
                 _sourceSolutionContents, projectTypeGuidMappings);
 
-            var convertedSolutionContents = _sourceSolutionContents.Replace(slnProjectReferenceReplacements);
+            var convertedSolutionContents = _textReplacementConverter.Replace(_sourceSolutionContents, slnProjectReferenceReplacements);
             return new ConversionResult(convertedSolutionContents) {
                 SourcePathOrNull = _solutionFilePath,
                 TargetPathOrNull = _solutionFilePath
diff --git a/CodeConverter/Shared/SolutionFileTextEditor.cs b/CodeConverter/Shared/SolutionFileTextEditor.cs
@@ -84,8 +84,15 @@ private static (string oldProjTypeReference, string newProjTypeReference) GetPro
         private static (string Find, string Replace, bool FirstOnly) GetProjectGuidReplacement(string projPath,
             string contents)
         {
-            var projGuidRegex = new Regex(projPath + @""", ""({[0-9A-Fa-f\-]{32,36}})("")");
+            var guidPattern = projPath + @""", ""({[0-9A-Fa-f\-]{32,36}})("")";
+            var projGuidRegex = new Regex(guidPattern);
             var projGuidMatch = projGuidRegex.Match(contents);
+
+            if (!projGuidMatch.Success) {
+                throw new OperationCanceledException($"{nameof(guidPattern)} {guidPattern} doesn't match with" +
+                                                     $" sourceSlnFileContents {contents}");
+            }
+
             var oldGuid = projGuidMatch.Groups[1].Value;
             var newGuid = GetDeterministicGuidFrom(new Guid(oldGuid));
             return (oldGuid, newGuid.ToString("B").ToUpperInvariant(), false);
diff --git a/CodeConverter/Shared/TextReplacementConverter.cs b/CodeConverter/Shared/TextReplacementConverter.cs
@@ -6,20 +6,26 @@ namespace ICSharpCode.CodeConverter.Shared
     using System.Text.RegularExpressions;
     using System.IO.Abstractions;
 
-    public static class TextReplacementConverter
+    public class TextReplacementConverter
     {
-        public static IFileSystem FileSystem { get; set; } = new FileSystem();
+        private readonly IFileSystem _fileSystem;
 
-        public static ConversionResult ConversionResultFromReplacements(this FileInfo filePath, IEnumerable<(string Find, string Replace, bool FirstOnly)> replacements, Func<string, string> postReplacementTransform = null)
+        public TextReplacementConverter(IFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+
+        public ConversionResult ConversionResultFromReplacements(FileInfo filePath, IEnumerable<(string Find, string Replace, bool FirstOnly)> replacements,
+            Func<string, string> postReplacementTransform = null)
         {
             postReplacementTransform ??= (s => s);
-            var oldProjectText = FileSystem.File.ReadAllText(filePath.FullName);
-            var newProjectText = oldProjectText.Replace(replacements);
+            var oldProjectText = _fileSystem.File.ReadAllText(filePath.FullName);
+            var newProjectText = Replace(oldProjectText, replacements);
             string withReplacements = postReplacementTransform(newProjectText);
             return new ConversionResult(withReplacements) { SourcePathOrNull = filePath.FullName, IsIdentity = oldProjectText == withReplacements};
         }
 
-        public static string Replace(this string originalText, IEnumerable<(string Find, string Replace, bool FirstOnly)> replacements)
+        public string Replace(string originalText, IEnumerable<(string Find, string Replace, bool FirstOnly)> replacements)
         {
             foreach (var (oldValue, newValue, firstOnly) in replacements) {
                 Regex regex = new Regex(oldValue, RegexOptions.IgnoreCase);
diff --git a/CodeConverter/Shared/ThreadSafeWorkspaceHelper.cs b/CodeConverter/Shared/ThreadSafeWorkspaceHelper.cs
@@ -18,11 +18,21 @@ namespace ICSharpCode.CodeConverter.Shared
     public static class ThreadSafeWorkspaceHelper
     {
         /// <summary>
-        /// Empty solution in an adhoc workspace
+        /// Create an empty adhoc workspace
         /// </summary>
-        public static AsyncLazy<Solution> EmptyAdhocSolution { get; } = new AsyncLazy<Solution>(async () => {
+        public static AsyncLazy<AdhocWorkspace> CreateAdhocWorkspace { get; } = new(async () =>
+        {
             var hostServices = await CreateHostServicesAsync(MefHostServices.DefaultAssemblies);
-            return new AdhocWorkspace(hostServices).CurrentSolution;
+            return new AdhocWorkspace(hostServices);
+        }, JoinableTaskFactorySingleton.Instance);
+
+        /// <summary>
+        /// Empty solution in an adhoc workspace
+        /// </summary>
+        public static AsyncLazy<Solution> EmptyAdhocSolution { get; } = new(async () =>
+        {
+            var adhocWorkspace = await CreateAdhocWorkspace.GetValueAsync();
+            return adhocWorkspace.CurrentSolution;
         }, JoinableTaskFactorySingleton.Instance);
 
         /// <summary>
diff --git a/Tests/CSharp/MultiFileSolutionAndProjectTests.cs b/Tests/CSharp/MultiFileSolutionAndProjectTests.cs
@@ -17,16 +17,14 @@ public MultiFileSolutionAndProjectTests(MultiFileTestFixture multiFileTestFixtur
             _multiFileTestFixture = multiFileTestFixture;
         }
 
-        //[Fact] /* enable for executing locally */
-        [Fact(Skip = "Doesn't work on Github actions agent")] /* disable for executing locally */
+        [Fact] /* enable for executing locally */
         public async Task ConvertWholeSolutionAsync()
         {
 
             await _multiFileTestFixture.ConvertProjectsWhereAsync(p => true, Language.CS);
         }
 
-        //[Fact] /* enable for executing locally */
-        [Fact(Skip = "Doesn't work on Github actions agent")]  /* disable for executing locally */
+        [Fact] /* enable for executing locally */
         public async Task ConvertVbLibraryOnlyAsync()
         {
             await _multiFileTestFixture.ConvertProjectsWhereAsync(p => p.Name == "VbLibrary", Language.CS);
diff --git a/Tests/LanguageAgnostic/SolutionFileTextEditorTests.cs b/Tests/LanguageAgnostic/SolutionFileTextEditorTests.cs
diff --git a/Tests/VB/MultiFileSolutionAndProjectTests.cs b/Tests/VB/MultiFileSolutionAndProjectTests.cs

Original file line number	Diff line number	Diff line change
`@@ -17,16 +17,14 @@ public MultiFileSolutionAndProjectTests(MultiFileTestFixture multiFileTestFixtur`
`17`	`17`	`_multiFileTestFixture = multiFileTestFixture;`
`18`	`18`	`}`
`19`	`19`
`20`		`- //[Fact] /* enable for executing locally */`
`21`		`- [Fact(Skip = "Doesn't work on Github actions agent")] /* disable for executing locally */`
	`20`	`+ [Fact] /* enable for executing locally */`
`22`	`21`	`public async Task ConvertWholeSolutionAsync()`
`23`	`22`	`{`
`24`	`23`
`25`	`24`	`await _multiFileTestFixture.ConvertProjectsWhereAsync(p => true, Language.CS);`
`26`	`25`	`}`
`27`	`26`
`28`		`- //[Fact] /* enable for executing locally */`
`29`		`- [Fact(Skip = "Doesn't work on Github actions agent")] /* disable for executing locally */`
	`27`	`+ [Fact] /* enable for executing locally */`
`30`	`28`	`public async Task ConvertVbLibraryOnlyAsync()`
`31`	`29`	`{`
`32`	`30`	`await _multiFileTestFixture.ConvertProjectsWhereAsync(p => p.Name == "VbLibrary", Language.CS);`