[Collectors]Output multiple formats (#533)

Allow multiple output format for collectors

Author: daveMueller

Documentation/VSTestIntegration.md

@@ -29,7 +29,7 @@ These are a list of options that are supported by coverlet. These can be specifi
 
 | Option         | Summary                                                                                  |
 |-------------   |------------------------------------------------------------------------------------------|
-|Format          | Coverage output format. These are either cobertura, json, lcov, opencover or teamcity.   | 
+|Format          | Coverage output format. These are either cobertura, json, lcov, opencover or teamcity as well as combinations of these formats.   | 
 |MergeWith       | Combine the output of multiple coverage runs into a single result.                       | 
 |Exclude         | Exclude from code coverage analysing using filter expressions.                           | 
 |ExcludeByFile   | Ignore specific source files from code coverage.                                         | 
@@ -46,7 +46,7 @@ How to specify these options via runsettings?
     <DataCollectors>
       <DataCollector friendlyName="XPlat code coverage">
         <Configuration>
-          <Format>json</Format>
+          <Format>json,cobertura</Format>
           <MergeWith>/custom/path/result.json</MergeWith>
           <Exclude>[coverlet.*.tests?]*,[*]Coverlet.Core*</Exclude> <!-- [Assembly-Filter]Type-Filter -->
           <Include>[coverlet.*]*,[*]Coverlet.Core*</Include> <!-- [Assembly-Filter]Type-Filter -->

src/coverlet.collector/DataCollection/AttachmentManager.cs

@@ -1,6 +1,7 @@
 using System;
 using System.ComponentModel;
 using System.IO;
+
 using coverlet.collector.Resources;
 using Coverlet.Collector.Utilities;
 using Coverlet.Collector.Utilities.Interfaces;
@@ -19,31 +20,31 @@ internal class AttachmentManager : IDisposable
         private readonly DataCollectionContext _dataCollectionContext;
         private readonly IFileHelper _fileHelper;
         private readonly IDirectoryHelper _directoryHelper;
-        private readonly string _reportFileName;
+        private readonly ICountDownEvent _countDownEvent;
         private readonly string _reportDirectory;
 
-        public AttachmentManager(DataCollectionSink dataSink, DataCollectionContext dataCollectionContext, TestPlatformLogger logger, TestPlatformEqtTrace eqtTrace, string reportFileName)
+        public AttachmentManager(DataCollectionSink dataSink, DataCollectionContext dataCollectionContext, TestPlatformLogger logger, TestPlatformEqtTrace eqtTrace, ICountDownEvent countDownEvent)
             : this(dataSink,
                   dataCollectionContext,
                   logger,
                   eqtTrace,
-                  reportFileName,
                   Guid.NewGuid().ToString(),
                   new FileHelper(),
-                  new DirectoryHelper())
+                  new DirectoryHelper(),
+                  countDownEvent)
         {
         }
 
-        public AttachmentManager(DataCollectionSink dataSink, DataCollectionContext dataCollectionContext, TestPlatformLogger logger, TestPlatformEqtTrace eqtTrace, string reportFileName, string reportDirectoryName, IFileHelper fileHelper, IDirectoryHelper directoryHelper)
+        public AttachmentManager(DataCollectionSink dataSink, DataCollectionContext dataCollectionContext, TestPlatformLogger logger, TestPlatformEqtTrace eqtTrace, string reportDirectoryName, IFileHelper fileHelper, IDirectoryHelper directoryHelper, ICountDownEvent countDownEvent)
         {
             // Store input variabless
             _dataSink = dataSink;
             _dataCollectionContext = dataCollectionContext;
             _logger = logger;
             _eqtTrace = eqtTrace;
-            _reportFileName = reportFileName;
             _fileHelper = fileHelper;
             _directoryHelper = directoryHelper;
+            _countDownEvent = countDownEvent;
 
             // Report directory to store the coverage reports.
             _reportDirectory = Path.Combine(Path.GetTempPath(), reportDirectoryName);
@@ -56,10 +57,11 @@ public AttachmentManager(DataCollectionSink dataSink, DataCollectionContext data
         /// Sends coverage report to test platform
         /// </summary>
         /// <param name="coverageReport">Coverage report</param>
-        public void SendCoverageReport(string coverageReport)
+        /// <param name="coverageReportFileName">Coverage report file name</param>
+        public void SendCoverageReport(string coverageReport, string coverageReportFileName)
         {
             // Save coverage report to file
-            string coverageReportPath = this.SaveCoverageReport(coverageReport);
+            string coverageReportPath = this.SaveCoverageReport(coverageReport, coverageReportFileName);
 
             // Send coverage attachment to test platform.
             this.SendAttachment(coverageReportPath);
@@ -73,6 +75,7 @@ public void Dispose()
             // Unregister events
             try
             {
+                _countDownEvent.Wait();
                 if (_dataSink != null)
                 {
                     _dataSink.SendFileCompleted -= this.OnSendFileCompleted;
@@ -89,21 +92,22 @@ public void Dispose()
         /// Saves coverage report to file system
         /// </summary>
         /// <param name="report">Coverage report</param>
+        /// <param name="reportFileName">Coverage report file name</param>
         /// <returns>Coverage report file path</returns>
-        private string SaveCoverageReport(string report)
+        private string SaveCoverageReport(string report, string reportFileName)
         {
             try
             {
                 _directoryHelper.CreateDirectory(_reportDirectory);
-                string filePath = Path.Combine(_reportDirectory, _reportFileName);
+                string filePath = Path.Combine(_reportDirectory, reportFileName);
                 _fileHelper.WriteAllText(filePath, report);
                 _eqtTrace.Info("{0}: Saved coverage report to path: '{1}'", CoverletConstants.DataCollectorName, filePath);
 
                 return filePath;
             }
             catch (Exception ex)
             {
-                string errorMessage = string.Format(Resources.FailedToSaveCoverageReport, CoverletConstants.DataCollectorName, _reportFileName, _reportDirectory);
+                string errorMessage = string.Format(Resources.FailedToSaveCoverageReport, CoverletConstants.DataCollectorName, reportFileName, _reportDirectory);
                 throw new CoverletDataCollectorException(errorMessage, ex);
             }
         }
@@ -118,12 +122,14 @@ public void OnSendFileCompleted(object sender, AsyncCompletedEventArgs e)
             try
             {
                 _eqtTrace.Verbose("{0}: SendFileCompleted received", CoverletConstants.DataCollectorName);
-                this.CleanupReportDirectory();
             }
             catch (Exception ex)
             {
                 _logger.LogWarning(ex.ToString());
-                this.Dispose();
+            }
+            finally
+            {
+                _countDownEvent.Signal();
             }
         }
 

src/coverlet.collector/DataCollection/CoverageManager.cs

@@ -1,4 +1,7 @@
 using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using coverlet.collector.Resources;
 using Coverlet.Collector.Utilities;
 using Coverlet.Collector.Utilities.Interfaces;
@@ -17,20 +20,32 @@ internal class CoverageManager
 
         private ICoverageWrapper _coverageWrapper;
 
-        public IReporter Reporter { get; }
+        public IReporter[] Reporters { get; }
 
         public CoverageManager(CoverletSettings settings, TestPlatformEqtTrace eqtTrace, TestPlatformLogger logger, ICoverageWrapper coverageWrapper)
             : this(settings,
-                  new ReporterFactory(settings.ReportFormat).CreateReporter(),
-                  new CoverletLogger(eqtTrace, logger),
-                  coverageWrapper)
+            settings.ReportFormats.Select(format =>
+            {
+                var reporterFactory = new ReporterFactory(format);
+                if (!reporterFactory.IsValidFormat())
+                {
+                    eqtTrace.Warning($"Invalid report format '{format}'");
+                    return null;
+                }
+                else
+                {
+                    return reporterFactory.CreateReporter();
+                }
+            }).Where(r => r != null).ToArray(),
+            new CoverletLogger(eqtTrace, logger),
+            coverageWrapper)
         {
         }
 
-        public CoverageManager(CoverletSettings settings, IReporter reporter, ILogger logger, ICoverageWrapper coverageWrapper)
+        public CoverageManager(CoverletSettings settings, IReporter[] reporters, ILogger logger, ICoverageWrapper coverageWrapper)
         {
             // Store input vars
-            Reporter = reporter;
+            Reporters = reporters;
             _coverageWrapper = coverageWrapper;
 
             // Coverage object
@@ -55,17 +70,14 @@ public void InstrumentModules()
         }
 
         /// <summary>
-        /// Gets coverlet coverage report
+        /// Gets coverlet coverage reports
         /// </summary>
-        /// <returns>Coverage report</returns>
-        public string GetCoverageReport()
+        /// <returns>Coverage reports</returns>
+        public IEnumerable<(string report, string fileName)> GetCoverageReports()
         {
             // Get coverage result
             CoverageResult coverageResult = this.GetCoverageResult();
-
-            // Get coverage report in default format
-            string coverageReport = this.GetCoverageReport(coverageResult);
-            return coverageReport;
+            return this.GetCoverageReports(coverageResult);
         }
 
         /// <summary>
@@ -86,15 +98,15 @@ private CoverageResult GetCoverageResult()
         }
 
         /// <summary>
-        /// Gets coverage report from coverage result
+        /// Gets coverage reports from coverage result
         /// </summary>
         /// <param name="coverageResult">Coverage result</param>
-        /// <returns>Coverage report</returns>
-        private string GetCoverageReport(CoverageResult coverageResult)
+        /// <returns>Coverage reports</returns>
+        private IEnumerable<(string report, string fileName)> GetCoverageReports(CoverageResult coverageResult)
         {
             try
             {
-                return Reporter.Report(coverageResult);
+                return Reporters.Select(reporter => (reporter.Report(coverageResult), Path.ChangeExtension(CoverletConstants.DefaultFileName, reporter.Extension)));
             }
             catch (Exception ex)
             {

src/coverlet.collector/DataCollection/CoverletCoverageCollector.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Xml;
 using Coverlet.Collector.Utilities;
@@ -23,15 +24,17 @@ public class CoverletCoverageCollector : DataCollector
         private DataCollectionContext _dataCollectionContext;
         private CoverageManager _coverageManager;
         private ICoverageWrapper _coverageWrapper;
+        private ICountDownEventFactory _countDownEventFactory;
 
-        public CoverletCoverageCollector() : this(new TestPlatformEqtTrace(), new CoverageWrapper())
+        public CoverletCoverageCollector() : this(new TestPlatformEqtTrace(), new CoverageWrapper(), new CollectorCountdownEventFactory())
         {
         }
 
-        internal CoverletCoverageCollector(TestPlatformEqtTrace eqtTrace, ICoverageWrapper coverageWrapper) : base()
+        internal CoverletCoverageCollector(TestPlatformEqtTrace eqtTrace, ICoverageWrapper coverageWrapper, ICountDownEventFactory countDownEventFactory) : base()
         {
             _eqtTrace = eqtTrace;
             _coverageWrapper = coverageWrapper;
+            _countDownEventFactory = countDownEventFactory;
         }
 
         /// <summary>
@@ -130,12 +133,23 @@ private void OnSessionEnd(object sender, SessionEndEventArgs e)
                 _eqtTrace.Verbose("{0}: SessionEnd received", CoverletConstants.DataCollectorName);
 
                 // Get coverage reports
-                string coverageReport = _coverageManager?.GetCoverageReport();
-
-                // Send result attachments to test platform.
-                var attachmentManager = new AttachmentManager(_dataSink, _dataCollectionContext, _logger, _eqtTrace, this.GetReportFileName());
-                attachmentManager?.SendCoverageReport(coverageReport);
-
+                IEnumerable<(string report, string fileName)> coverageReports = _coverageManager?.GetCoverageReports();
+
+                if (coverageReports != null && coverageReports.Count() > 0)
+                {
+                    // Send result attachments to test platform.
+                    using (var attachmentManager = new AttachmentManager(_dataSink, _dataCollectionContext, _logger, _eqtTrace, _countDownEventFactory.Create(coverageReports.Count(), TimeSpan.FromSeconds(30))))
+                    {
+                        foreach ((string report, string fileName) in coverageReports)
+                        {
+                            attachmentManager.SendCoverageReport(report, fileName);
+                        }
+                    }
+                }
+                else
+                {
+                    _eqtTrace.Verbose("{0}: No coverage reports specified", CoverletConstants.DataCollectorName);
+                }
             }
             catch (Exception ex)
             {
@@ -144,18 +158,6 @@ private void OnSessionEnd(object sender, SessionEndEventArgs e)
             }
         }
 
-        /// <summary>
-        /// Gets coverage report file name
-        /// </summary>
-        /// <returns>Coverage report file name</returns>
-        private string GetReportFileName()
-        {
-            string fileName = CoverletConstants.DefaultFileName;
-            string extension = _coverageManager?.Reporter.Extension;
-
-            return extension == null ? fileName : $"{fileName}.{extension}";
-        }
-
         /// <summary>
         /// Gets test modules
         /// </summary>

src/coverlet.collector/DataCollection/CoverletSettings.cs

@@ -14,9 +14,9 @@ internal class CoverletSettings
         public string TestModule { get; set; }
 
         /// <summary>
-        /// Report format
+        /// Report formats
         /// </summary>
-        public string ReportFormat { get; set; }
+        public string[] ReportFormats { get; set; }
 
         /// <summary>
         /// Filters to include

src/coverlet.collector/DataCollection/CoverletSettingsParser.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Xml;
 using coverlet.collector.Resources;
@@ -43,7 +44,7 @@ public CoverletSettings Parse(XmlElement configurationElement, IEnumerable<strin
                 coverletSettings.IncludeTestAssembly = this.ParseIncludeTestAssembly(configurationElement);
             }
 
-            coverletSettings.ReportFormat = this.ParseReportFormat(configurationElement);
+            coverletSettings.ReportFormats = this.ParseReportFormats(configurationElement);
             coverletSettings.ExcludeFilters = this.ParseExcludeFilters(configurationElement);
 
             if (_eqtTrace.IsVerboseEnabled)
@@ -75,19 +76,21 @@ private string ParseTestModule(IEnumerable<string> testModules)
         }
 
         /// <summary>
-        /// Parse report format
+        /// Parse report formats
         /// </summary>
         /// <param name="configurationElement">Configuration element</param>
-        /// <returns>Report format</returns>
-        private string ParseReportFormat(XmlElement configurationElement)
+        /// <returns>Report formats</returns>
+        private string[] ParseReportFormats(XmlElement configurationElement)
         {
-            string format = string.Empty;
+            string[] formats = Array.Empty<string>();
             if (configurationElement != null)
             {
                 XmlElement reportFormatElement = configurationElement[CoverletConstants.ReportFormatElementName];
-                format = reportFormatElement?.InnerText?.Split(',').FirstOrDefault();
+                formats = reportFormatElement?.InnerText?.Split(',').Select(format => format.Trim())
+                    .Where(format => !string.IsNullOrEmpty(format)).ToArray();
             }
-            return string.IsNullOrEmpty(format) ? CoverletConstants.DefaultReportFormat : format;
+
+            return formats is null || formats.Length == 0 ? new[] {CoverletConstants.DefaultReportFormat} : formats;
         }
 
         /// <summary>

src/coverlet.collector/Utilities/CountDownEvent.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Threading;
+
+using Coverlet.Collector.Utilities.Interfaces;
+
+namespace Coverlet.Collector.Utilities
+{
+    internal class CollectorCountdownEventFactory : ICountDownEventFactory
+    {
+        public ICountDownEvent Create(int count, TimeSpan waitTimeout)
+        {
+            return new CollectorCountdownEvent(count, waitTimeout);
+        }
+    }
+
+    internal class CollectorCountdownEvent : ICountDownEvent
+    {
+        private readonly CountdownEvent _countDownEvent;
+        private readonly TimeSpan _waitTimeout;
+
+        public CollectorCountdownEvent(int count, TimeSpan waitTimeout)
+        {
+            _countDownEvent = new CountdownEvent(count);
+            _waitTimeout = waitTimeout;
+        }
+
+        public void Signal()
+        {
+            _countDownEvent.Signal();
+        }
+
+        public void Wait()
+        {
+            // We wait on another thread to avoid to block forever
+            // We could use Task/Task.Delay timeout trick but this api and collector are sync so to
+            // avoid too much GetAwaiter()/GetResult() I prefer keep code simple.
+            // This thread is created only one time where we pass coverage files 
+            var waitOnThread = new Thread(() => _countDownEvent.Wait());
+            waitOnThread.Start();
+            waitOnThread.Join(_waitTimeout);
+        }
+    }
+}