FortuneN · tonyhallett · May 15, 2021
diff --git a/FineCodeCoverage/Core/Cobertura/CoberturaUtil.cs b/FineCodeCoverage/Core/Cobertura/CoberturaUtil.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using FineCodeCoverage.Engine.Model;
 using System.ComponentModel.Composition;
+using System.IO;
 
 namespace FineCodeCoverage.Engine.Cobertura
 {
@@ -16,9 +17,9 @@ internal class CoberturaUtil:ICoberturaUtil
 		private CoverageReport coverageReport;
 		public List<CoverageLine> CoverageLines { get; private set; }
 
-		private CoverageReport LoadReportFile(string inputFilePath)
+		private CoverageReport LoadReport(string xml)
 		{
-			using (var reader = XmlReader.Create(inputFilePath, READER_SETTINGS))
+			using (var reader = XmlReader.Create(new StringReader(xml), READER_SETTINGS))
 			{
 				var report = (CoverageReport)SERIALIZER.Deserialize(reader);
 				return report;
@@ -67,11 +68,11 @@ private CoverageReport LoadReportFile(string inputFilePath)
 		//	return jsonText;
 		//}
 
-		public void ProcessCoberturaXmlFile(string xmlFilePath)
+		public void ProcessCoberturaXml(string xml)
 		{
 			CoverageLines = new List<CoverageLine>();
 
-			coverageReport = LoadReportFile(xmlFilePath);
+			coverageReport = LoadReport(xml);
 
 			foreach (var package in coverageReport.Packages.Package)
 			{

diff --git a/FineCodeCoverage/Core/Cobertura/ICoberturaUtil.cs b/FineCodeCoverage/Core/Cobertura/ICoberturaUtil.cs
@@ -7,7 +7,7 @@ interface ICoberturaUtil
     {
 		List<CoverageLine> CoverageLines { get; }
 
-		void ProcessCoberturaXmlFile(string xmlFilePath);
+		void ProcessCoberturaXml(string xml);
 		string[] GetSourceFiles(string assemblyName, string qualifiedClassName, int file);
 	}
 }
diff --git a/FineCodeCoverage/Core/CoverageToolOutputManager.cs b/FineCodeCoverage/Core/CoverageToolOutputManager.cs
@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.IO;
+using System.Linq;
+using FineCodeCoverage.Core.Utilities;
+using FineCodeCoverage.Engine.Model;
+
+namespace FineCodeCoverage.Engine
+{
+    [Export(typeof(ICoverageToolOutputManager))]
+    internal class CoverageToolOutputManager : ICoverageToolOutputManager
+    {
+        private readonly ILogger logger;
+        private readonly IFileUtil fileUtil;
+        private const string unifiedHtmlFileName = "index.html";
+        private const string unifiedXmlFileName = "Cobertura.xml";
+        private const string processedHtmlFileName = "index-processed.html";
+        private const string projectCoverageToolOutputFolderName = "coverage-tool-output";
+        private string outputFolderForAllProjects;
+        private List<ICoverageProject> coverageProjects;
+
+        [ImportingConstructor]
+        public CoverageToolOutputManager(IFileUtil fileUtil, ILogger logger)
+        {
+            this.logger = logger;
+            this.fileUtil = fileUtil;
+        }
+
+        public void SetProjectCoverageOutputFolder(List<ICoverageProject> coverageProjects)
+        {
+            this.coverageProjects = coverageProjects;
+            DetermineOutputFolderForAllProjects();
+            if(outputFolderForAllProjects == null)
+            {
+                foreach(var coverageProject in coverageProjects)
+                {
+                    coverageProject.CoverageOutputFolder = Path.Combine(coverageProject.FCCOutputFolder, projectCoverageToolOutputFolderName);
+                }
+            }
+            else
+            {
+                fileUtil.TryEmptyDirectory(outputFolderForAllProjects);
+                foreach (var coverageProject in coverageProjects)
+                {
+                    coverageProject.CoverageOutputFolder = Path.Combine(outputFolderForAllProjects, coverageProject.ProjectName);
+                }
+            }
+        }
+
+        public void SetReportOutput(string unifiedHtml, string processedReport, string unifiedXml)
+        {
+            var outputFolder = outputFolderForAllProjects ?? coverageProjects[0].CoverageOutputFolder;
+
+            fileUtil.WriteAllText(Path.Combine(outputFolder, unifiedHtmlFileName), unifiedHtml);
+            fileUtil.WriteAllText(Path.Combine(outputFolder, processedHtmlFileName), processedReport);
+            fileUtil.WriteAllText(Path.Combine(outputFolder, unifiedXmlFileName), unifiedXml);
+        }
+
+        private void DetermineOutputFolderForAllProjects()
+        {
+            outputFolderForAllProjects = null;
+            var coverageProjectWithAllProjectsCoverageOutputFolder = coverageProjects.FirstOrDefault(cp => cp.AllProjectsCoverageOutputFolder != null);
+            if(coverageProjectWithAllProjectsCoverageOutputFolder != null)
+            {
+                var allProjectsCoverageOutputFolder = fileUtil.EnsureAbsolute(
+                    coverageProjectWithAllProjectsCoverageOutputFolder.AllProjectsCoverageOutputFolder,
+                    fileUtil.ParentDirectoryPath(coverageProjectWithAllProjectsCoverageOutputFolder.ProjectFile)
+                );
+
+                outputFolderForAllProjects = allProjectsCoverageOutputFolder;
+                logger.Log($"Outputting coverage files to - {outputFolderForAllProjects}");
+                return;
+            }
+
+
+            logger.Log($"Outputting coverage files in project output folder");
+
+        }
+    }
+}
diff --git a/FineCodeCoverage/Core/FCCEngine.cs b/FineCodeCoverage/Core/FCCEngine.cs
@@ -22,7 +22,6 @@ internal class FCCEngine : IFCCEngine
     {
         internal int InitializeWait { get; set; } = 5000;
         internal const string initializationFailedMessagePrefix = "Initialization failed.  Please check the following error which may be resolved by reopening visual studio which will start the initialization process again.";
-        internal const string errorReadingReportGeneratorOutputMessage = "error reading report generator output";
         private readonly object colorThemeService;
         private string CurrentTheme => $"{((dynamic)colorThemeService)?.CurrentTheme?.Name}".Trim();
 
@@ -44,6 +43,7 @@ internal class FCCEngine : IFCCEngine
         private readonly IAppDataFolder appDataFolder;
         private readonly IServiceProvider serviceProvider;
         private IInitializeStatusProvider initializeStatusProvider;
+        private readonly ICoverageToolOutputManager coverageOutputManager;
         internal System.Threading.Tasks.Task reloadCoverageTask;
 
         [ImportingConstructor]
@@ -56,10 +56,12 @@ public FCCEngine(
             IAppOptionsProvider appOptionsProvider,
             ILogger logger,
             IAppDataFolder appDataFolder,
+            ICoverageToolOutputManager coverageOutputManager,
             [Import(typeof(SVsServiceProvider))]
             IServiceProvider serviceProvider
             )
         {
+            this.coverageOutputManager = coverageOutputManager;
             this.coverageUtilManager = coverageUtilManager;
             this.coberturaUtil = coberturaUtil;
             this.msTestPlatformUtil = msTestPlatformUtil;
@@ -142,54 +144,38 @@ private async System.Threading.Tasks.Task<string[]> RunCoverageAsync(List<ICover
 
         }
 
-        private void RaiseUpdateOutputWindow(string reportFilePath)
+        private void RaiseUpdateOutputWindow(string reportHtml)
         {
-            UpdateOutputWindowEventArgs updateOutputWindowEventArgs = new UpdateOutputWindowEventArgs { };
-
-            try
-            {
-                if (!string.IsNullOrEmpty(reportFilePath))
-                {
-                    var htmlContent = File.ReadAllText(reportFilePath);
-                    updateOutputWindowEventArgs.HtmlContent = htmlContent;
-                }
-            }
-            catch
-            {
-                logger.Log(errorReadingReportGeneratorOutputMessage);
-            }
-            finally
-            {
-                UpdateOutputWindow?.Invoke(updateOutputWindowEventArgs);
-            }
+            UpdateOutputWindowEventArgs updateOutputWindowEventArgs = new UpdateOutputWindowEventArgs { HtmlContent = reportHtml};
+            UpdateOutputWindow?.Invoke(updateOutputWindowEventArgs);
         }
-        private void UpdateUI(List<CoverageLine> coverageLines, string reportFilePath)
+        private void UpdateUI(List<CoverageLine> coverageLines, string reportHtml)
         {
             CoverageLines = coverageLines;
             UpdateMarginTags?.Invoke(new UpdateMarginTagsEventArgs());
-            RaiseUpdateOutputWindow(reportFilePath);
+            RaiseUpdateOutputWindow(reportHtml);
         }
 
         private async System.Threading.Tasks.Task<(List<CoverageLine> coverageLines,string reportFilePath)> RunAndProcessReportAsync(string[] coverOutputFiles,CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
             List<CoverageLine> coverageLines = null;
-            string reportFilePath = null;
+            string processedReport = null;
 
             var darkMode = CurrentTheme.Equals("Dark", StringComparison.OrdinalIgnoreCase);
 
             var result = await reportGeneratorUtil.RunReportGeneratorAsync(coverOutputFiles, darkMode, true);
 
             if (result.Success)
             {
-                coberturaUtil.ProcessCoberturaXmlFile(result.UnifiedXmlFile);
+                coberturaUtil.ProcessCoberturaXml(result.UnifiedXml);
                 coverageLines = coberturaUtil.CoverageLines;
 
-                reportGeneratorUtil.ProcessUnifiedHtmlFile(result.UnifiedHtmlFile, darkMode, out var htmlFilePath);
-                reportFilePath = htmlFilePath;
+                processedReport = reportGeneratorUtil.ProcessUnifiedHtml(result.UnifiedHtml, darkMode);
+                coverageOutputManager.SetReportOutput(result.UnifiedHtml, processedReport, result.UnifiedXml);
             }
-            return (coverageLines, reportFilePath);
+            return (coverageLines, processedReport);
         }
 
         private async System.Threading.Tasks.Task PrepareCoverageProjectsAsync(List<ICoverageProject> coverageProjects, CancellationToken cancellationToken)
@@ -213,7 +199,7 @@ private async System.Threading.Tasks.Task PrepareCoverageProjectsAsync(List<ICov
             }
         }
 
-        private void ReloadCoverageTaskContinuation(System.Threading.Tasks.Task<(List<CoverageLine> coverageLines, string reportFilePath)> t)
+        private void ReloadCoverageTaskContinuation(System.Threading.Tasks.Task<(List<CoverageLine> coverageLines, string reportHtml)> t)
         {
             switch (t.Status)
             {
@@ -228,7 +214,7 @@ private void ReloadCoverageTaskContinuation(System.Threading.Tasks.Task<(List<Co
                 case System.Threading.Tasks.TaskStatus.RanToCompletion:
                     LogReloadCoverageStatus(ReloadCoverageStatus.Done);
 #pragma warning disable VSTHRD002 // Avoid problematic synchronous waits
-                    UpdateUI(t.Result.coverageLines, t.Result.reportFilePath);
+                    UpdateUI(t.Result.coverageLines, t.Result.reportHtml);
 #pragma warning restore VSTHRD002 // Avoid problematic synchronous waits
                     break;
             }
@@ -263,24 +249,26 @@ public void ReloadCoverage(Func<System.Threading.Tasks.Task<List<ICoverageProjec
             reloadCoverageTask = System.Threading.Tasks.Task.Run(async () =>
             {
                 List<CoverageLine> coverageLines = null;
-                string reportFilePath = null;
+                string reportHtml = null;
 
                 await PollInitializedStatusAsync(cancellationToken);
 
                 LogReloadCoverageStatus(ReloadCoverageStatus.Start);
 
                 var coverageProjects = await coverageRequestCallback();
 
+                coverageOutputManager.SetProjectCoverageOutputFolder(coverageProjects);
+
                 var coverOutputFiles = await RunCoverageAsync(coverageProjects, cancellationToken);
 
                 if (coverOutputFiles.Any())
                 {
-                    var (lines, rFilePath) = await RunAndProcessReportAsync(coverOutputFiles,cancellationToken);
+                    var (lines, report) = await RunAndProcessReportAsync(coverOutputFiles,cancellationToken);
                     coverageLines = lines;
-                    reportFilePath = rFilePath;
+                    reportHtml = report;
                 }
 
-                return (coverageLines, reportFilePath);
+                return (coverageLines, reportHtml);
 
             }, cancellationToken)
             .ContinueWith(t =>

diff --git a/FineCodeCoverage/Core/ICoverageToolOutputManager.cs b/FineCodeCoverage/Core/ICoverageToolOutputManager.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using FineCodeCoverage.Engine.Model;
+
+namespace FineCodeCoverage.Engine
+{
+    internal interface ICoverageToolOutputManager
+    {
+        void SetProjectCoverageOutputFolder(List<ICoverageProject> coverageProjects);
+        void SetReportOutput(string unifiedHtml, string processedReport, string unifiedXml);
+    }
+}
diff --git a/FineCodeCoverage/Core/Model/CoverageProject.cs b/FineCodeCoverage/Core/Model/CoverageProject.cs
@@ -24,10 +24,9 @@ internal class CoverageProject : ICoverageProject
         private readonly bool canUseMsBuildWorkspace;
         private XElement projectFileXElement;
         private IAppOptions settings;
-        private string fccPath;
         private readonly string fccFolderName = "fine-code-coverage";
         private readonly string buildOutputFolderName = "build-output";
-        private string buildOutputPath;
+        private string BuildOutputPath => Path.Combine(FCCOutputFolder, buildOutputFolderName);
         private readonly string coverageToolOutputFolderName = "coverage-tool-output";
 
         public CoverageProject(IAppOptionsProvider appOptionsProvider, IFileSynchronizationUtil fileSynchronizationUtil, ILogger logger, DTE dte, bool canUseMsBuildWorkspace)
@@ -39,6 +38,9 @@ public CoverageProject(IAppOptionsProvider appOptionsProvider, IFileSynchronizat
             this.canUseMsBuildWorkspace = canUseMsBuildWorkspace;
         }
 
+        public string AllProjectsCoverageOutputFolder => ProjectFileXElement.XPathSelectElement($"/PropertyGroup/AllProjectsCoverageOutputFolder")?.Value;
+
+        public string FCCOutputFolder => Path.Combine(ProjectOutputFolder, fccFolderName);
         public bool IsDotNetSdkStyle()
         {
             return ProjectFileXElement
@@ -126,7 +128,7 @@ public bool IsDotNetSdkStyle()
         public bool HasFailed => !string.IsNullOrWhiteSpace(FailureStage) || !string.IsNullOrWhiteSpace(FailureDescription);
         public string ProjectFile { get; set; }
         public string ProjectName { get; set; }
-        public string CoverageOutputFile { get; set; }
+        public string CoverageOutputFile => Path.Combine(CoverageOutputFolder, $"{ProjectName}.coverage.xml");
 
         private bool TypeMatch(Type type, params Type[] otherTypes)
         {
@@ -356,7 +358,6 @@ public async System.Threading.Tasks.Task StepAsync(string stepName, Func<ICovera
 
         public async System.Threading.Tasks.Task PrepareForCoverageAsync()
         {
-            SetPaths();
             EnsureDirectories();
             CleanDirectory();
             SynchronizeBuildOutput();
@@ -493,13 +494,6 @@ private async Task<List<ReferencedProject>> GetReferencedProjectsFromProjectFile
             return referencedProjectFiles.Select(referencedProjectProjectFile => new ReferencedProject(referencedProjectProjectFile)).ToList();
         }
 
-        private void SetPaths()
-        {
-            fccPath = Path.Combine(ProjectOutputFolder, fccFolderName);
-            buildOutputPath = Path.Combine(fccPath, buildOutputFolderName);
-            CoverageOutputFolder = Path.Combine(fccPath, coverageToolOutputFolderName);
-            CoverageOutputFile = Path.Combine(CoverageOutputFolder, $"{ProjectName}.coverage.xml");
-        }
         private void EnsureDirectories()
         {
             EnsureFccDirectory();
@@ -508,11 +502,11 @@ private void EnsureDirectories()
         }
         private void EnsureFccDirectory()
         {
-            CreateIfDoesNotExist(fccPath);
+            CreateIfDoesNotExist(FCCOutputFolder);
         }
         private void EnsureBuildOutputDirectory()
         {
-            CreateIfDoesNotExist(buildOutputPath);
+            CreateIfDoesNotExist(BuildOutputPath);
         }
         private void CreateIfDoesNotExist(string path)
         {
@@ -546,7 +540,7 @@ private void EnsureEmptyOutputFolder()
         private void CleanDirectory()
         {
             var exclusions = new List<string> { buildOutputFolderName, coverageToolOutputFolderName };
-            var fccDirectory = new DirectoryInfo(fccPath);
+            var fccDirectory = new DirectoryInfo(FCCOutputFolder);
 
             fccDirectory.EnumerateFileSystemInfos().AsParallel().ForAll(fileOrDirectory =>
                {
@@ -570,8 +564,8 @@ private void CleanDirectory()
         }
         private void SynchronizeBuildOutput()
         {
-            fileSynchronizationUtil.Synchronize(ProjectOutputFolder, buildOutputPath, fccFolderName);
-            TestDllFile = Path.Combine(buildOutputPath, Path.GetFileName(TestDllFile));
+            fileSynchronizationUtil.Synchronize(ProjectOutputFolder, BuildOutputPath, fccFolderName);
+            TestDllFile = Path.Combine(BuildOutputPath, Path.GetFileName(TestDllFile));
         }
 
     }

diff --git a/FineCodeCoverage/Core/Model/ICoverageProject.cs b/FineCodeCoverage/Core/Model/ICoverageProject.cs
@@ -8,7 +8,9 @@ namespace FineCodeCoverage.Engine.Model
 {
     internal interface ICoverageProject
     {
-        string CoverageOutputFile { get; set; }
+        string AllProjectsCoverageOutputFolder { get; }
+        string FCCOutputFolder { get; }
+        string CoverageOutputFile { get; }
         string CoverageOutputFolder { get; set; }
         List<string> ExcludedReferencedProjects { get; }
         string FailureDescription { get; set; }