Refactor file system operations to use IFileSystem interface

Replaced direct file and directory operations with IFileSystem methods. This change standardizes file system interactions and simplifies dependency injection across the codebase.

Author: arturcic

src/GitVersion.App.Tests/ArgumentParserTests.cs

@@ -12,6 +12,7 @@ public class ArgumentParserTests : TestBase
 {
     private IEnvironment environment;
     private IArgumentParser argumentParser;
+    private IFileSystem fileSystem;
 
     [SetUp]
     public void SetUp()
@@ -23,6 +24,7 @@ public void SetUp()
         });
         this.environment = sp.GetRequiredService<IEnvironment>();
         this.argumentParser = sp.GetRequiredService<IArgumentParser>();
+        this.fileSystem = sp.GetRequiredService<IFileSystem>();
     }
 
     [Test]
@@ -337,7 +339,8 @@ public void UpdateAssemblyInfoWithMultipleFilenamesMatchingGlobbing()
         using var file2 = File.Create(assemblyFile2);
 
         var subdir = PathHelper.Combine(repo.RepositoryPath, "subdir");
-        Directory.CreateDirectory(subdir);
+
+        this.fileSystem.CreateDirectory(subdir);
         var assemblyFile3 = PathHelper.Combine(subdir, "LocalAssemblyInfo.cs");
         using var file3 = File.Create(assemblyFile3);
 
@@ -358,7 +361,7 @@ public void UpdateAssemblyInfoWithRelativeFilename()
         using var file = File.Create(assemblyFile);
 
         var targetPath = PathHelper.Combine(repo.RepositoryPath, "subdir1", "subdir2");
-        Directory.CreateDirectory(targetPath);
+        this.fileSystem.CreateDirectory(targetPath);
 
         var arguments = this.argumentParser.ParseArguments($"-targetpath {targetPath} -updateAssemblyInfo ..\\..\\CommonAssemblyInfo.cs");
         arguments.UpdateAssemblyInfo.ShouldBe(true);

src/GitVersion.App/ArgumentParser.cs

@@ -6,10 +6,15 @@
 
 namespace GitVersion;
 
-internal class ArgumentParser(IEnvironment environment, ICurrentBuildAgent buildAgent, IConsole console, IGlobbingResolver globbingResolver)
+internal class ArgumentParser(IEnvironment environment,
+                              IFileSystem fileSystem,
+                              ICurrentBuildAgent buildAgent,
+                              IConsole console,
+                              IGlobbingResolver globbingResolver)
     : IArgumentParser
 {
     private readonly IEnvironment environment = environment.NotNull();
+    private readonly IFileSystem fileSystem = fileSystem.NotNull();
     private readonly ICurrentBuildAgent buildAgent = buildAgent.NotNull();
     private readonly IConsole console = console.NotNull();
     private readonly IGlobbingResolver globbingResolver = globbingResolver.NotNull();
@@ -97,19 +102,19 @@ public Arguments ParseArguments(string[] commandLineArguments)
         return arguments;
     }
 
-    private static void ValidateConfigurationFile(Arguments arguments)
+    private void ValidateConfigurationFile(Arguments arguments)
     {
         if (arguments.ConfigurationFile.IsNullOrWhiteSpace()) return;
 
         if (Path.IsPathRooted(arguments.ConfigurationFile))
         {
-            if (!File.Exists(arguments.ConfigurationFile)) throw new WarningException($"Could not find config file at '{arguments.ConfigurationFile}'");
+            if (!this.fileSystem.Exists(arguments.ConfigurationFile)) throw new WarningException($"Could not find config file at '{arguments.ConfigurationFile}'");
             arguments.ConfigurationFile = Path.GetFullPath(arguments.ConfigurationFile);
         }
         else
         {
             var configFilePath = Path.GetFullPath(PathHelper.Combine(arguments.TargetPath, arguments.ConfigurationFile));
-            if (!File.Exists(configFilePath)) throw new WarningException($"Could not find config file at '{configFilePath}'");
+            if (!this.fileSystem.Exists(configFilePath)) throw new WarningException($"Could not find config file at '{configFilePath}'");
             arguments.ConfigurationFile = configFilePath;
         }
     }
@@ -161,7 +166,7 @@ private void ParseTargetPath(Arguments arguments, string? name, IReadOnlyList<st
         {
             EnsureArgumentValueCount(values);
             arguments.TargetPath = value;
-            if (!Directory.Exists(value))
+            if (!this.fileSystem.DirectoryExists(value))
             {
                 this.console.WriteLine($"The working directory '{value}' does not exist.");
             }

src/GitVersion.App/GitVersionExecutor.cs

@@ -8,6 +8,7 @@ namespace GitVersion;
 
 internal class GitVersionExecutor(
     ILog log,
+    IFileSystem fileSystem,
     IConsole console,
     IVersionWriter versionWriter,
     IHelpWriter helpWriter,
@@ -21,6 +22,7 @@ internal class GitVersionExecutor(
     : IGitVersionExecutor
 {
     private readonly ILog log = log.NotNull();
+    private readonly IFileSystem fileSystem = fileSystem.NotNull();
     private readonly IConsole console = console.NotNull();
     private readonly IVersionWriter versionWriter = versionWriter.NotNull();
     private readonly IHelpWriter helpWriter = helpWriter.NotNull();
@@ -131,7 +133,7 @@ private bool HandleNonMainCommand(GitVersionOptions gitVersionOptions, out int e
             GitExtensions.DumpGraphLog(logMessage => this.log.Info(logMessage));
         }
 
-        if (!Directory.Exists(workingDirectory))
+        if (!this.fileSystem.DirectoryExists(workingDirectory))
         {
             this.log.Warning($"The working directory '{workingDirectory}' does not exist.");
         }

src/GitVersion.Configuration/ConfigurationProvider.cs

@@ -21,7 +21,7 @@ public IGitVersionConfiguration Provide(IReadOnlyDictionary<object, object?>? ov
     {
         var gitVersionOptions = this.options.Value;
         var workingDirectory = gitVersionOptions.WorkingDirectory;
-        var projectRootDirectory = workingDirectory.FindGitDir()?.WorkingTreeDirectory;
+        var projectRootDirectory = this.fileSystem.FindGitDir(workingDirectory)?.WorkingTreeDirectory;
 
         var configurationFile = this.configFileLocator.GetConfigurationFile(workingDirectory)
                              ?? this.configFileLocator.GetConfigurationFile(projectRootDirectory);

src/GitVersion.Core.Tests/Core/DynamicRepositoryTests.cs

@@ -11,16 +11,7 @@ public class DynamicRepositoryTests : TestBase
     private string? workDirectory;
 
     [SetUp]
-    public void SetUp()
-    {
-        // // Note: we can't use guid because paths will be too long
-        this.workDirectory = PathHelper.Combine(Path.GetTempPath(), "GV");
-
-        if (!Directory.Exists(this.workDirectory))
-        {
-            Directory.CreateDirectory(this.workDirectory);
-        }
-    }
+    public void SetUp() => this.workDirectory = PathHelper.Combine(Path.GetTempPath(), "GV");
 
     [TearDown]
     public void TearDown()
@@ -50,16 +41,17 @@ public void FindsVersionInDynamicRepo(string name, string url, string targetBran
         };
         var options = Options.Create(gitVersionOptions);
 
-        Directory.CreateDirectory(dynamicDirectory);
-        Directory.CreateDirectory(workingDirectory);
-
         var sp = ConfigureServices(services => services.AddSingleton(options));
 
         sp.DiscoverRepository();
 
         var gitPreparer = sp.GetRequiredService<IGitPreparer>();
         gitPreparer.Prepare();
 
+        var fileSystem = sp.GetRequiredService<IFileSystem>();
+        fileSystem.CreateDirectory(dynamicDirectory);
+        fileSystem.CreateDirectory(workingDirectory);
+
         var gitVersionCalculator = sp.GetRequiredService<IGitVersionCalculateTool>();
 
         var versionVariables = gitVersionCalculator.CalculateVersionVariables();

src/GitVersion.Core.Tests/Core/GitVersionExecutorTests.cs

@@ -67,7 +67,7 @@ public void CacheKeyForWorktree()
     {
         using var fixture = new EmptyRepositoryFixture();
         fixture.Repository.MakeACommit();
-        var worktreePath = PathHelper.Combine(Directory.GetParent(fixture.RepositoryPath)?.FullName, Guid.NewGuid().ToString());
+        var worktreePath = GetWorktreePath(fixture);
         try
         {
             // create a branch and a new worktree for it
@@ -395,7 +395,7 @@ public void GetProjectRootDirectoryWorkingDirectoryWithWorktree()
         using var fixture = new EmptyRepositoryFixture();
         fixture.Repository.MakeACommit();
 
-        var worktreePath = PathHelper.Combine(Directory.GetParent(fixture.RepositoryPath)?.FullName, Guid.NewGuid().ToString());
+        var worktreePath = GetWorktreePath(fixture);
         try
         {
             // create a branch and a new worktree for it
@@ -451,7 +451,7 @@ public void GetDotGitDirectoryWorktree()
         using var fixture = new EmptyRepositoryFixture();
         fixture.Repository.MakeACommit();
 
-        var worktreePath = PathHelper.Combine(Directory.GetParent(fixture.RepositoryPath)?.FullName, Guid.NewGuid().ToString());
+        var worktreePath = GetWorktreePath(fixture);
         try
         {
             // create a branch and a new worktree for it
@@ -588,6 +588,12 @@ public void CalculateVersionVariables_ShallowFetch_ThrowException()
         exception?.Message.ShouldBe("Repository is a shallow clone. Git repositories must contain the full history. See https://gitversion.net/docs/reference/requirements#unshallow for more info.");
     }
 
+    private static string GetWorktreePath(EmptyRepositoryFixture fixture)
+    {
+        var worktreePath = PathHelper.Combine(Directory.GetParent(fixture.RepositoryPath)?.FullName, Guid.NewGuid().ToString());
+        return worktreePath;
+    }
+
     private IGitVersionCalculateTool GetGitVersionCalculator(GitVersionOptions gitVersionOptions, ILog? logger = null, IGitRepository? repository = null, IFileSystem? fs = null)
     {
         this.sp = GetServiceProvider(gitVersionOptions, logger, repository, fs);

src/GitVersion.Core/Core/Abstractions/IFileSystem.cs

@@ -9,10 +9,12 @@ public interface IFileSystem
     string ReadAllText(string path);
     void WriteAllText(string? file, string fileContents);
     void WriteAllText(string? file, string fileContents, Encoding encoding);
-    IEnumerable<string> DirectoryEnumerateFiles(string? directory, string searchPattern, SearchOption searchOption);
     Stream OpenWrite(string path);
     Stream OpenRead(string path);
     void CreateDirectory(string path);
     bool DirectoryExists(string path);
+    string[] GetFiles(string path);
+    string[] GetDirectories(string path);
+    IEnumerable<string> DirectoryEnumerateFiles(string? directory, string searchPattern, SearchOption searchOption);
     long GetLastDirectoryWrite(string path);
 }

src/GitVersion.Core/Core/FileSystem.cs

@@ -29,13 +29,6 @@ public void WriteAllText(string? file, string fileContents, Encoding encoding)
         File.WriteAllText(file, fileContents, encoding);
     }
 
-    public IEnumerable<string> DirectoryEnumerateFiles(string? directory, string searchPattern, SearchOption searchOption)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(directory);
-
-        return Directory.EnumerateFiles(directory, searchPattern, searchOption);
-    }
-
     public Stream OpenWrite(string path) => File.OpenWrite(path);
 
     public Stream OpenRead(string path) => File.OpenRead(path);
@@ -44,6 +37,17 @@ public IEnumerable<string> DirectoryEnumerateFiles(string? directory, string sea
 
     public bool DirectoryExists(string path) => Directory.Exists(path);
 
+    public string[] GetFiles(string path) => Directory.GetFiles(path);
+
+    public string[] GetDirectories(string path) => Directory.GetDirectories(path);
+
+    public IEnumerable<string> DirectoryEnumerateFiles(string? directory, string searchPattern, SearchOption searchOption)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(directory);
+
+        return Directory.EnumerateFiles(directory, searchPattern, searchOption);
+    }
+
     public long GetLastDirectoryWrite(string path) => new DirectoryInfo(path)
         .GetDirectories("*.*", SearchOption.AllDirectories)
         .Select(d => d.LastWriteTimeUtc)

src/GitVersion.Core/Core/GitPreparer.cs

@@ -10,6 +10,7 @@ namespace GitVersion;
 
 internal class GitPreparer(
     ILog log,
+    IFileSystem fileSystem,
     IEnvironment environment,
     ICurrentBuildAgent buildAgent,
     IOptions<GitVersionOptions> options,
@@ -19,6 +20,7 @@ internal class GitPreparer(
     : IGitPreparer
 {
     private readonly ILog log = log.NotNull();
+    private readonly IFileSystem fileSystem = fileSystem.NotNull();
     private readonly IEnvironment environment = environment.NotNull();
     private readonly IMutatingGitRepository repository = repository.NotNull();
     private readonly IOptions<GitVersionOptions> options = options.NotNull();
@@ -112,7 +114,7 @@ private void CreateDynamicRepository(string? targetBranch)
         {
             var gitVersionOptions = this.options.Value;
             var authentication = gitVersionOptions.AuthenticationInfo;
-            if (!Directory.Exists(gitDirectory))
+            if (!this.fileSystem.DirectoryExists(gitDirectory))
             {
                 CloneRepository(gitVersionOptions.RepositoryInfo.TargetUrl, gitDirectory, authentication);
             }

src/GitVersion.Core/Extensions/ConfigurationExtensions.cs

@@ -123,24 +123,24 @@ public static bool IsReleaseBranch(this IGitVersionConfiguration configuration,
         return label;
     }
 
-    public static (string GitDirectory, string WorkingTreeDirectory)? FindGitDir(this string path)
+    public static (string GitDirectory, string WorkingTreeDirectory)? FindGitDir(this IFileSystem fileSystem, string path)
     {
         string? startingDir = path;
         while (startingDir is not null)
         {
             var dirOrFilePath = PathHelper.Combine(startingDir, ".git");
-            if (Directory.Exists(dirOrFilePath))
+            if (fileSystem.DirectoryExists(dirOrFilePath))
             {
                 return (dirOrFilePath, Path.GetDirectoryName(dirOrFilePath)!);
             }
 
-            if (File.Exists(dirOrFilePath))
+            if (fileSystem.Exists(dirOrFilePath))
             {
                 string? relativeGitDirPath = ReadGitDirFromFile(dirOrFilePath);
                 if (!string.IsNullOrWhiteSpace(relativeGitDirPath))
                 {
                     var fullGitDirPath = Path.GetFullPath(PathHelper.Combine(startingDir, relativeGitDirPath));
-                    if (Directory.Exists(fullGitDirPath))
+                    if (fileSystem.DirectoryExists(fullGitDirPath))
                     {
                         return (fullGitDirPath, Path.GetDirectoryName(dirOrFilePath)!);
                     }