SystemIOFile Adapter

src/coverlet.collector/DataCollection/CoverageWrapper.cs

@@ -30,6 +30,7 @@ public Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger
                 settings.MergeWith,
                 settings.UseSourceLink,
                 coverletLogger,
+                (IFileSystem)DependencyInjection.Current.GetService(typeof(IFileSystem)),
                 (IInstrumentationHelper)DependencyInjection.Current.GetService(typeof(IInstrumentationHelper)));
         }
 

src/coverlet.console/Program.cs

@@ -59,7 +59,7 @@ static int Main(string[] args)
                     // Adjust log level based on user input.
                     logger.Level = verbosity.ParsedValue;
                 }
-
+                var fileSystem = (IFileSystem)DependencyInjection.Current.GetService(typeof(IFileSystem));
                 Coverage coverage = new Coverage(module.Value,
                     includeFilters.Values.ToArray(),
                     includeDirectories.Values.ToArray(),
@@ -71,6 +71,7 @@ static int Main(string[] args)
                     mergeWith.Value(),
                     useSourceLink.HasValue(),
                     logger,
+                    fileSystem,
                     (IInstrumentationHelper)DependencyInjection.Current.GetService(typeof(IInstrumentationHelper)));
                 coverage.PrepareModules();
 
@@ -140,7 +141,7 @@ static int Main(string[] args)
 
                         var report = Path.Combine(directory, filename);
                         logger.LogInformation($"  Generating report '{report}'", important: true);
-                        File.WriteAllText(report, reporter.Report(result));
+                        fileSystem.WriteAllText(report, reporter.Report(result));
                     }
                 }
 

src/coverlet.core/Abstracts/IFileSystem.cs

@@ -1,7 +1,27 @@
-namespace Coverlet.Core.Abstracts
+using System.IO;
+
+namespace Coverlet.Core.Abstracts
 {
-    internal interface IFileSystem
+    public interface IFileSystem
     {
         bool Exists(string path);
+
+        void WriteAllText(string path, string contents);
+
+        string ReadAllText(string path);
+
+        Stream OpenRead(string path);
+
+        void Copy(string sourceFileName, string destFileName);
+
+        void Copy(string sourceFileName, string destFileName, bool overwrite);
+
+        void Delete(string path);
+
+        void AppendAllText(string path, string contents);
+
+        Stream NewFileStream(string path, FileMode mode);
+
+        Stream NewFileStream(string path, FileMode mode, FileAccess access);
     }
 }

src/coverlet.core/Coverage.cs

@@ -3,7 +3,6 @@
 using System.IO;
 using System.Linq;
 using Coverlet.Core.Abstracts;
-using Coverlet.Core.Helpers;
 using Coverlet.Core.Instrumentation;
 using Coverlet.Core.Logging;
 
@@ -27,6 +26,7 @@ public class Coverage
         private bool _useSourceLink;
         private ILogger _logger;
         private IInstrumentationHelper _instrumentationHelper;
+        private IFileSystem _fileSystem;
         private List<InstrumenterResult> _results;
 
         public string Identifier
@@ -45,6 +45,7 @@ public Coverage(string module,
             string mergeWith,
             bool useSourceLink,
             ILogger logger,
+            IFileSystem fileSystem,
             IInstrumentationHelper instrumentationHelper)
         {
             _module = module;
@@ -58,20 +59,22 @@ public Coverage(string module,
             _mergeWith = mergeWith;
             _useSourceLink = useSourceLink;
             _logger = logger;
+            _fileSystem = fileSystem;
             _instrumentationHelper = instrumentationHelper;
 
             _identifier = Guid.NewGuid().ToString();
             _results = new List<InstrumenterResult>();
         }
 
-        public Coverage(CoveragePrepareResult prepareResult, ILogger logger, IInstrumentationHelper instrumentationHelper)
+        public Coverage(CoveragePrepareResult prepareResult, ILogger logger, IFileSystem fileSystem, IInstrumentationHelper instrumentationHelper)
         {
             _identifier = prepareResult.Identifier;
             _module = prepareResult.Module;
             _mergeWith = prepareResult.MergeWith;
             _useSourceLink = prepareResult.UseSourceLink;
             _results = new List<InstrumenterResult>(prepareResult.Results);
             _logger = logger;
+            _fileSystem = fileSystem;
             _instrumentationHelper = instrumentationHelper;
         }
 
@@ -215,9 +218,9 @@ public CoverageResult GetCoverageResult()
 
             var coverageResult = new CoverageResult { Identifier = _identifier, Modules = modules, InstrumentedResults = _results };
 
-            if (!string.IsNullOrEmpty(_mergeWith) && !string.IsNullOrWhiteSpace(_mergeWith) && File.Exists(_mergeWith))
+            if (!string.IsNullOrEmpty(_mergeWith) && !string.IsNullOrWhiteSpace(_mergeWith) && _fileSystem.Exists(_mergeWith))
             {
-                string json = File.ReadAllText(_mergeWith);
+                string json = _fileSystem.ReadAllText(_mergeWith);
                 coverageResult.Merge(JsonConvert.DeserializeObject<Modules>(json));
             }
 
@@ -228,7 +231,7 @@ private void CalculateCoverage()
         {
             foreach (var result in _results)
             {
-                if (!File.Exists(result.HitsFilePath))
+                if (!_fileSystem.Exists(result.HitsFilePath))
                 {
                     // Hits file could be missed mainly for two reason
                     // 1) Issue during module Unload()
@@ -249,7 +252,7 @@ private void CalculateCoverage()
                     }
                 }
 
-                using (var fs = new FileStream(result.HitsFilePath, FileMode.Open))
+                using (var fs = _fileSystem.NewFileStream(result.HitsFilePath, FileMode.Open))
                 using (var br = new BinaryReader(fs))
                 {
                     int hitCandidatesCount = br.ReadInt32();

src/coverlet.core/Helpers/FileSystem.cs

@@ -3,11 +3,56 @@
 
 namespace Coverlet.Core.Helpers
 {
-    internal class FileSystem : IFileSystem
+    public class FileSystem : IFileSystem
     {
         public bool Exists(string path)
         {
             return File.Exists(path);
         }
+
+        public void WriteAllText(string path, string contents)
+        {
+            File.WriteAllText(path, contents);
+        }
+
+        public string ReadAllText(string path)
+        {
+            return File.ReadAllText(path);
+        }
+
+        public Stream OpenRead(string path)
+        {
+            return File.OpenRead(path);
+        }
+
+        public void Copy(string sourceFileName, string destFileName)
+        {
+            File.Copy(sourceFileName, destFileName);
+        }
+
+        public void Copy(string sourceFileName, string destFileName, bool overwrite)
+        {
+            File.Copy(sourceFileName, destFileName, overwrite);
+        }
+
+        public void Delete(string path)
+        {
+            File.Delete(path);
+        }
+
+        public void AppendAllText(string path, string contents)
+        {
+            File.AppendAllText(path, contents);
+        }
+
+        public Stream NewFileStream(string path, FileMode mode)
+        {
+            return new FileStream(path, mode);
+        }
+
+        public Stream NewFileStream(string path, FileMode mode, FileAccess access)
+        {
+            return new FileStream(path, mode, access);
+        }
     }
 }

src/coverlet.core/Helpers/InstrumentationHelper.cs

@@ -9,7 +9,6 @@
 using System.Reflection.PortableExecutable;
 using System.Text.RegularExpressions;
 using Coverlet.Core.Abstracts;
-using Coverlet.Core.Logging;
 
 namespace Coverlet.Core.Helpers
 {
@@ -73,7 +72,7 @@ public string[] GetCoverableModules(string module, string[] directories, bool in
         public bool HasPdb(string module, out bool embedded)
         {
             embedded = false;
-            using (var moduleStream = File.OpenRead(module))
+            using (var moduleStream = _fileSystem.OpenRead(module))
             using (var peReader = new PEReader(moduleStream))
             {
                 foreach (var entry in peReader.ReadDebugDirectory())
@@ -88,7 +87,7 @@ public bool HasPdb(string module, out bool embedded)
                             return true;
                         }
 
-                        return File.Exists(codeViewData.Path);
+                        return _fileSystem.Exists(codeViewData.Path);
                     }
                 }
 
@@ -99,7 +98,7 @@ public bool HasPdb(string module, out bool embedded)
         public bool EmbeddedPortablePdbHasLocalSource(string module, out string firstNotFoundDocument)
         {
             firstNotFoundDocument = "";
-            using (FileStream moduleStream = File.OpenRead(module))
+            using (FileStream moduleStream = _fileSystem.OpenRead(module) as FileStream)
             using (var peReader = new PEReader(moduleStream))
             {
                 foreach (DebugDirectoryEntry entry in peReader.ReadDebugDirectory())
@@ -117,7 +116,7 @@ public bool EmbeddedPortablePdbHasLocalSource(string module, out string firstNot
                                 // We verify all docs and return false if not all are present in local
                                 // We could have false negative if doc is not a source
                                 // Btw check for all possible extension could be weak approach
-                                if (!File.Exists(docName))
+                                if (!_fileSystem.Exists(docName))
                                 {
                                     firstNotFoundDocument = docName;
                                     return false;
@@ -136,15 +135,15 @@ public bool EmbeddedPortablePdbHasLocalSource(string module, out string firstNot
         public bool PortablePdbHasLocalSource(string module, out string firstNotFoundDocument)
         {
             firstNotFoundDocument = "";
-            using (var moduleStream = File.OpenRead(module))
+            using (var moduleStream = _fileSystem.OpenRead(module))
             using (var peReader = new PEReader(moduleStream))
             {
                 foreach (var entry in peReader.ReadDebugDirectory())
                 {
                     if (entry.Type == DebugDirectoryEntryType.CodeView)
                     {
                         var codeViewData = peReader.ReadCodeViewDebugDirectoryData(entry);
-                        using FileStream pdbStream = new FileStream(codeViewData.Path, FileMode.Open);
+                        using FileStream pdbStream = _fileSystem.NewFileStream(codeViewData.Path, FileMode.Open) as FileStream;
                         using MetadataReaderProvider metadataReaderProvider = MetadataReaderProvider.FromPortablePdbStream(pdbStream);
                         MetadataReader metadataReader = metadataReaderProvider.GetMetadataReader();
                         foreach (DocumentHandle docHandle in metadataReader.Documents)
@@ -172,16 +171,16 @@ public void BackupOriginalModule(string module, string identifier)
         {
             var backupPath = GetBackupPath(module, identifier);
             var backupSymbolPath = Path.ChangeExtension(backupPath, ".pdb");
-            File.Copy(module, backupPath, true);
+            _fileSystem.Copy(module, backupPath, true);
             if (!_backupList.TryAdd(module, backupPath))
             {
                 throw new ArgumentException($"Key already added '{module}'");
             }
 
             var symbolFile = Path.ChangeExtension(module, ".pdb");
-            if (File.Exists(symbolFile))
+            if (_fileSystem.Exists(symbolFile))
             {
-                File.Copy(symbolFile, backupSymbolPath, true);
+                _fileSystem.Copy(symbolFile, backupSymbolPath, true);
                 if (!_backupList.TryAdd(symbolFile, backupSymbolPath))
                 {
                     throw new ArgumentException($"Key already added '{module}'");
@@ -200,18 +199,18 @@ public void RestoreOriginalModule(string module, string identifier)
 
             _retryHelper.Retry(() =>
             {
-                File.Copy(backupPath, module, true);
-                File.Delete(backupPath);
+                _fileSystem.Copy(backupPath, module, true);
+                _fileSystem.Delete(backupPath);
                 _backupList.TryRemove(module, out string _);
             }, retryStrategy, 10);
 
             _retryHelper.Retry(() =>
             {
-                if (File.Exists(backupSymbolPath))
+                if (_fileSystem.Exists(backupSymbolPath))
                 {
                     string symbolFile = Path.ChangeExtension(module, ".pdb");
-                    File.Copy(backupSymbolPath, symbolFile, true);
-                    File.Delete(backupSymbolPath);
+                    _fileSystem.Copy(backupSymbolPath, symbolFile, true);
+                    _fileSystem.Delete(backupSymbolPath);
                     _backupList.TryRemove(symbolFile, out string _);
                 }
             }, retryStrategy, 10);
@@ -228,8 +227,8 @@ public void RestoreOriginalModules()
                 string backupPath = _backupList[key];
                 _retryHelper.Retry(() =>
                 {
-                    File.Copy(backupPath, key, true);
-                    File.Delete(backupPath);
+                    _fileSystem.Copy(backupPath, key, true);
+                    _fileSystem.Delete(backupPath);
                     _backupList.TryRemove(key, out string _);
                 }, retryStrategy, 10);
             }
@@ -240,7 +239,7 @@ public void DeleteHitsFile(string path)
             // Retry hitting the hits file - retry up to 10 times, since the file could be locked
             // See: https://github.com/tonerdo/coverlet/issues/25
             var retryStrategy = CreateRetryStrategy();
-            _retryHelper.Retry(() => File.Delete(path), retryStrategy, 10);
+            _retryHelper.Retry(() => _fileSystem.Delete(path), retryStrategy, 10);
         }
 
         public bool IsValidFilterExpression(string filter)

src/coverlet.msbuild.tasks/CoverageResultTask.cs

@@ -75,13 +75,14 @@ public override bool Execute()
             {
                 Console.WriteLine("\nCalculating coverage result...");
 
-                if (InstrumenterState is null || !File.Exists(InstrumenterState.ItemSpec))
+                IFileSystem fileSystem = (IFileSystem)DependencyInjection.Current.GetService(typeof(IFileSystem));
+                if (InstrumenterState is null || !fileSystem.Exists(InstrumenterState.ItemSpec))
                 {
                     _logger.LogError("Result of instrumentation task not found");
                     return false;
                 }
 
-                var coverage = new Coverage(CoveragePrepareResult.Deserialize(new FileStream(InstrumenterState.ItemSpec, FileMode.Open)), this._logger, (IInstrumentationHelper)DependencyInjection.Current.GetService(typeof(IInstrumentationHelper)));
+                var coverage = new Coverage(CoveragePrepareResult.Deserialize(new FileStream(InstrumenterState.ItemSpec, FileMode.Open)), this._logger, fileSystem, (IInstrumentationHelper)DependencyInjection.Current.GetService(typeof(IInstrumentationHelper)));
                 var result = coverage.GetCoverageResult();
 
                 var directory = Path.GetDirectoryName(_output);
@@ -118,7 +119,7 @@ public override bool Execute()
 
                         var report = Path.Combine(directory, filename);
                         Console.WriteLine($"  Generating report '{report}'");
-                        File.WriteAllText(report, reporter.Report(result));
+                        fileSystem.WriteAllText(report, reporter.Report(result));
                     }
                 }
 

src/coverlet.msbuild.tasks/InstrumentationTask.cs

@@ -106,7 +106,20 @@ public override bool Execute()
                 var excludedSourceFiles = _excludeByFile?.Split(',');
                 var excludeAttributes = _excludeByAttribute?.Split(',');
 
-                Coverage coverage = new Coverage(_path, includeFilters, includeDirectories, excludeFilters, excludedSourceFiles, excludeAttributes, _includeTestAssembly, _singleHit, _mergeWith, _useSourceLink, _logger, (IInstrumentationHelper)DependencyInjection.Current.GetService(typeof(IInstrumentationHelper)));
+                Coverage coverage = new Coverage(_path,
+                    includeFilters,
+                    includeDirectories,
+                    excludeFilters,
+                    excludedSourceFiles,
+                    excludeAttributes,
+                    _includeTestAssembly,
+                    _singleHit,
+                    _mergeWith,
+                    _useSourceLink,
+                    _logger,
+                    (IFileSystem) DependencyInjection.Current.GetService(typeof(IFileSystem)),
+                    (IInstrumentationHelper) DependencyInjection.Current.GetService(typeof(IInstrumentationHelper)));
+
                 CoveragePrepareResult prepareResult = coverage.PrepareModules();
                 InstrumenterState = new TaskItem(System.IO.Path.GetTempFileName());
                 using (var instrumentedStateFile = new FileStream(InstrumenterState.ItemSpec, FileMode.Open, FileAccess.Write))

test/coverlet.collector.tests/CoverletCoverageDataCollectorTests.cs

@@ -74,7 +74,7 @@ public void OnSessionStartShouldPrepareModulesForCoverage()
                     null,
                     _context);
             IDictionary<string, object> sessionStartProperties = new Dictionary<string, object>();
-            Coverage coverage = new Coverage("abc.dll", null, null, null, null, null, true, true, "abc.json", true, It.IsAny<ILogger>(), (IInstrumentationHelper)DependencyInjection.Current.GetService(typeof(IInstrumentationHelper)));
+            Coverage coverage = new Coverage("abc.dll", null, null, null, null, null, true, true, "abc.json", true, It.IsAny<ILogger>(), (IFileSystem)DependencyInjection.Current.GetService(typeof(IFileSystem)), (IInstrumentationHelper)DependencyInjection.Current.GetService(typeof(IInstrumentationHelper)));
 
             sessionStartProperties.Add("TestSources", new List<string> { "abc.dll" });
             _mockCoverageWrapper.Setup(x => x.CreateCoverage(It.IsAny<CoverletSettings>(), It.IsAny<ILogger>())).Returns(coverage);