Refactor file system operations to use IFileSystem interface

arturcic · arturcic · commit 5147e957b93a · 2024-12-09T12:16:07.000+01:00
Replaced direct file and directory operations with IFileSystem methods. This change standardizes file system interactions and simplifies dependency injection across the codebase.
diff --git a/src/GitVersion.App.Tests/ArgumentParserTests.cs b/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);
diff --git a/src/GitVersion.App/ArgumentParser.cs b/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.");
             }
diff --git a/src/GitVersion.App/GitVersionExecutor.cs b/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.");
         }
diff --git a/src/GitVersion.Configuration/ConfigurationProvider.cs b/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);
diff --git a/src/GitVersion.Core.Tests/Core/DynamicRepositoryTests.cs b/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();
diff --git a/src/GitVersion.Core.Tests/Core/GitVersionExecutorTests.cs b/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);
diff --git a/src/GitVersion.Core/Core/Abstractions/IFileSystem.cs b/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);
 }
diff --git a/src/GitVersion.Core/Core/FileSystem.cs b/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)
diff --git a/src/GitVersion.Core/Core/GitPreparer.cs b/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);
             }
diff --git a/src/GitVersion.Core/Extensions/ConfigurationExtensions.cs b/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)!);
                     }
diff --git a/src/GitVersion.Core/PublicAPI.Unshipped.txt b/src/GitVersion.Core/PublicAPI.Unshipped.txt
@@ -1 +1,3 @@
 #nullable enable
+GitVersion.IFileSystem.GetDirectories(string! path) -> string![]!
+GitVersion.IFileSystem.GetFiles(string! path) -> string![]!
diff --git a/src/GitVersion.Core/VersionCalculation/Caching/GitVersionCacheKeyFactory.cs b/src/GitVersion.Core/VersionCalculation/Caching/GitVersionCacheKeyFactory.cs
@@ -57,7 +57,7 @@ private List<string> CalculateDirectoryContents(string root)
         // examined for files.
         var dirs = new Stack<string>();
 
-        if (!Directory.Exists(root))
+        if (!this.fileSystem.DirectoryExists(root))
         {
             throw new DirectoryNotFoundException($"Root directory does not exist: {root}");
         }
@@ -74,7 +74,7 @@ private List<string> CalculateDirectoryContents(string root)
             string[] subDirs;
             try
             {
-                subDirs = Directory.GetDirectories(currentDir);
+                subDirs = this.fileSystem.GetDirectories(currentDir);
             }
             // An UnauthorizedAccessException exception will be thrown if we do not have
             // discovery permission on a folder or file. It may or may not be acceptable
@@ -99,7 +99,7 @@ private List<string> CalculateDirectoryContents(string root)
             string[] files;
             try
             {
-                files = Directory.GetFiles(currentDir);
+                files = this.fileSystem.GetFiles(currentDir);
             }
             catch (UnauthorizedAccessException e)
             {
diff --git a/src/GitVersion.MsBuild/GitVersionTaskExecutor.cs b/src/GitVersion.MsBuild/GitVersionTaskExecutor.cs
@@ -34,7 +34,7 @@ public void GetVersion(GetVersion task)
     public void UpdateAssemblyInfo(UpdateAssemblyInfo task)
     {
         var versionVariables = GitVersionVariables(task);
-        FileHelper.DeleteTempFiles();
+        DeleteTempFiles();
         FileHelper.CheckForInvalidFiles(task.CompileFiles, task.ProjectFile);
 
         if (!string.IsNullOrEmpty(task.IntermediateOutputPath))
@@ -100,5 +100,27 @@ public void WriteVersionInfoToBuildLog(WriteVersionInfoToBuildLog task)
         gitVersionOutputTool.OutputVariables(versionVariables, configuration.UpdateBuildNumber);
     }
 
+    private void DeleteTempFiles()
+    {
+        if (!this.fileSystem.DirectoryExists(FileHelper.TempPath))
+        {
+            return;
+        }
+
+        foreach (var file in this.fileSystem.GetFiles(FileHelper.TempPath))
+        {
+            if (File.GetLastWriteTime(file) >= DateTime.Now.AddDays(-1))
+                continue;
+            try
+            {
+                File.Delete(file);
+            }
+            catch (UnauthorizedAccessException)
+            {
+                //ignore contention
+            }
+        }
+    }
+
     private GitVersionVariables GitVersionVariables(GitVersionTaskBase task) => serializer.FromFile(task.VersionFile);
 }
diff --git a/src/GitVersion.MsBuild/Helpers/FileHelper.cs b/src/GitVersion.MsBuild/Helpers/FileHelper.cs
diff --git a/src/GitVersion.Output.Tests/Output/GitVersionInfoGeneratorTests.cs b/src/GitVersion.Output.Tests/Output/GitVersionInfoGeneratorTests.cs

Original file line number	Diff line number	Diff line change
`@@ -6,10 +6,15 @@`
`6`	`6`
`7`	`7`	`namespace GitVersion;`
`8`	`8`
`9`		`-internal class ArgumentParser(IEnvironment environment, ICurrentBuildAgent buildAgent, IConsole console, IGlobbingResolver globbingResolver)`
	`9`	`+internal class ArgumentParser(IEnvironment environment,`
	`10`	`+ IFileSystem fileSystem,`
	`11`	`+ ICurrentBuildAgent buildAgent,`
	`12`	`+ IConsole console,`
	`13`	`+ IGlobbingResolver globbingResolver)`
`10`	`14`	`: IArgumentParser`
`11`	`15`	`{`
`12`	`16`	`private readonly IEnvironment environment = environment.NotNull();`
	`17`	`+ private readonly IFileSystem fileSystem = fileSystem.NotNull();`
`13`	`18`	`private readonly ICurrentBuildAgent buildAgent = buildAgent.NotNull();`
`14`	`19`	`private readonly IConsole console = console.NotNull();`
`15`	`20`	`private readonly IGlobbingResolver globbingResolver = globbingResolver.NotNull();`
`@@ -97,19 +102,19 @@ public Arguments ParseArguments(string[] commandLineArguments)`
`97`	`102`	`return arguments;`
`98`	`103`	`}`
`99`	`104`
`100`		`- private static void ValidateConfigurationFile(Arguments arguments)`
	`105`	`+ private void ValidateConfigurationFile(Arguments arguments)`
`101`	`106`	`{`
`102`	`107`	`if (arguments.ConfigurationFile.IsNullOrWhiteSpace()) return;`
`103`	`108`
`104`	`109`	`if (Path.IsPathRooted(arguments.ConfigurationFile))`
`105`	`110`	`{`
`106`		`- if (!File.Exists(arguments.ConfigurationFile)) throw new WarningException($"Could not find config file at '{arguments.ConfigurationFile}'");`
	`111`	`+ if (!this.fileSystem.Exists(arguments.ConfigurationFile)) throw new WarningException($"Could not find config file at '{arguments.ConfigurationFile}'");`
`107`	`112`	`arguments.ConfigurationFile = Path.GetFullPath(arguments.ConfigurationFile);`
`108`	`113`	`}`
`109`	`114`	`else`
`110`	`115`	`{`
`111`	`116`	`var configFilePath = Path.GetFullPath(PathHelper.Combine(arguments.TargetPath, arguments.ConfigurationFile));`
`112`		`- if (!File.Exists(configFilePath)) throw new WarningException($"Could not find config file at '{configFilePath}'");`
	`117`	`+ if (!this.fileSystem.Exists(configFilePath)) throw new WarningException($"Could not find config file at '{configFilePath}'");`
`113`	`118`	`arguments.ConfigurationFile = configFilePath;`
`114`	`119`	`}`
`115`	`120`	`}`
`@@ -161,7 +166,7 @@ private void ParseTargetPath(Arguments arguments, string? name, IReadOnlyList<st`
`161`	`166`	`{`
`162`	`167`	`EnsureArgumentValueCount(values);`
`163`	`168`	`arguments.TargetPath = value;`
`164`		`- if (!Directory.Exists(value))`
	`169`	`+ if (!this.fileSystem.DirectoryExists(value))`
`165`	`170`	`{`
`166`	`171`	`this.console.WriteLine($"The working directory '{value}' does not exist.");`
`167`	`172`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@ namespace GitVersion;`
`8`	`8`
`9`	`9`	`internal class GitVersionExecutor(`
`10`	`10`	`ILog log,`
	`11`	`+ IFileSystem fileSystem,`
`11`	`12`	`IConsole console,`
`12`	`13`	`IVersionWriter versionWriter,`
`13`	`14`	`IHelpWriter helpWriter,`
`@@ -21,6 +22,7 @@ internal class GitVersionExecutor(`
`21`	`22`	`: IGitVersionExecutor`
`22`	`23`	`{`
`23`	`24`	`private readonly ILog log = log.NotNull();`
	`25`	`+ private readonly IFileSystem fileSystem = fileSystem.NotNull();`
`24`	`26`	`private readonly IConsole console = console.NotNull();`
`25`	`27`	`private readonly IVersionWriter versionWriter = versionWriter.NotNull();`
`26`	`28`	`private readonly IHelpWriter helpWriter = helpWriter.NotNull();`
`@@ -131,7 +133,7 @@ private bool HandleNonMainCommand(GitVersionOptions gitVersionOptions, out int e`
`131`	`133`	`GitExtensions.DumpGraphLog(logMessage => this.log.Info(logMessage));`
`132`	`134`	`}`
`133`	`135`
`134`		`- if (!Directory.Exists(workingDirectory))`
	`136`	`+ if (!this.fileSystem.DirectoryExists(workingDirectory))`
`135`	`137`	`{`
`136`	`138`	`this.log.Warning($"The working directory '{workingDirectory}' does not exist.");`
`137`	`139`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public IGitVersionConfiguration Provide(IReadOnlyDictionary<object, object?>? ov`
`21`	`21`	`{`
`22`	`22`	`var gitVersionOptions = this.options.Value;`
`23`	`23`	`var workingDirectory = gitVersionOptions.WorkingDirectory;`
`24`		`- var projectRootDirectory = workingDirectory.FindGitDir()?.WorkingTreeDirectory;`
	`24`	`+ var projectRootDirectory = this.fileSystem.FindGitDir(workingDirectory)?.WorkingTreeDirectory;`
`25`	`25`
`26`	`26`	`var configurationFile = this.configFileLocator.GetConfigurationFile(workingDirectory)`
`27`	`27`	`?? this.configFileLocator.GetConfigurationFile(projectRootDirectory);`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ public void CacheKeyForWorktree()`
`67`	`67`	`{`
`68`	`68`	`using var fixture = new EmptyRepositoryFixture();`
`69`	`69`	`fixture.Repository.MakeACommit();`
`70`		`- var worktreePath = PathHelper.Combine(Directory.GetParent(fixture.RepositoryPath)?.FullName, Guid.NewGuid().ToString());`
	`70`	`+ var worktreePath = GetWorktreePath(fixture);`
`71`	`71`	`try`
`72`	`72`	`{`
`73`	`73`	`// create a branch and a new worktree for it`
`@@ -395,7 +395,7 @@ public void GetProjectRootDirectoryWorkingDirectoryWithWorktree()`
`395`	`395`	`using var fixture = new EmptyRepositoryFixture();`
`396`	`396`	`fixture.Repository.MakeACommit();`
`397`	`397`
`398`		`- var worktreePath = PathHelper.Combine(Directory.GetParent(fixture.RepositoryPath)?.FullName, Guid.NewGuid().ToString());`
	`398`	`+ var worktreePath = GetWorktreePath(fixture);`
`399`	`399`	`try`
`400`	`400`	`{`
`401`	`401`	`// create a branch and a new worktree for it`
`@@ -451,7 +451,7 @@ public void GetDotGitDirectoryWorktree()`
`451`	`451`	`using var fixture = new EmptyRepositoryFixture();`
`452`	`452`	`fixture.Repository.MakeACommit();`
`453`	`453`
`454`		`- var worktreePath = PathHelper.Combine(Directory.GetParent(fixture.RepositoryPath)?.FullName, Guid.NewGuid().ToString());`
	`454`	`+ var worktreePath = GetWorktreePath(fixture);`
`455`	`455`	`try`
`456`	`456`	`{`
`457`	`457`	`// create a branch and a new worktree for it`
`@@ -588,6 +588,12 @@ public void CalculateVersionVariables_ShallowFetch_ThrowException()`
`588`	`588`	`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.");`
`589`	`589`	`}`
`590`	`590`
	`591`	`+ private static string GetWorktreePath(EmptyRepositoryFixture fixture)`
	`592`	`+ {`
	`593`	`+ var worktreePath = PathHelper.Combine(Directory.GetParent(fixture.RepositoryPath)?.FullName, Guid.NewGuid().ToString());`
	`594`	`+ return worktreePath;`
	`595`	`+ }`
	`596`	`+`
`591`	`597`	`private IGitVersionCalculateTool GetGitVersionCalculator(GitVersionOptions gitVersionOptions, ILog? logger = null, IGitRepository? repository = null, IFileSystem? fs = null)`
`592`	`598`	`{`
`593`	`599`	`this.sp = GetServiceProvider(gitVersionOptions, logger, repository, fs);`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ namespace GitVersion;`
`10`	`10`
`11`	`11`	`internal class GitPreparer(`
`12`	`12`	`ILog log,`
	`13`	`+ IFileSystem fileSystem,`
`13`	`14`	`IEnvironment environment,`
`14`	`15`	`ICurrentBuildAgent buildAgent,`
`15`	`16`	`IOptions<GitVersionOptions> options,`
`@@ -19,6 +20,7 @@ internal class GitPreparer(`
`19`	`20`	`: IGitPreparer`
`20`	`21`	`{`
`21`	`22`	`private readonly ILog log = log.NotNull();`
	`23`	`+ private readonly IFileSystem fileSystem = fileSystem.NotNull();`
`22`	`24`	`private readonly IEnvironment environment = environment.NotNull();`
`23`	`25`	`private readonly IMutatingGitRepository repository = repository.NotNull();`
`24`	`26`	`private readonly IOptions<GitVersionOptions> options = options.NotNull();`
`@@ -112,7 +114,7 @@ private void CreateDynamicRepository(string? targetBranch)`
`112`	`114`	`{`
`113`	`115`	`var gitVersionOptions = this.options.Value;`
`114`	`116`	`var authentication = gitVersionOptions.AuthenticationInfo;`
`115`		`- if (!Directory.Exists(gitDirectory))`
	`117`	`+ if (!this.fileSystem.DirectoryExists(gitDirectory))`
`116`	`118`	`{`
`117`	`119`	`CloneRepository(gitVersionOptions.RepositoryInfo.TargetUrl, gitDirectory, authentication);`
`118`	`120`	`}`
Original file line number	Diff line number	Diff line change
`@@ -123,24 +123,24 @@ public static bool IsReleaseBranch(this IGitVersionConfiguration configuration,`
`123`	`123`	`return label;`
`124`	`124`	`}`
`125`	`125`
`126`		`- public static (string GitDirectory, string WorkingTreeDirectory)? FindGitDir(this string path)`
	`126`	`+ public static (string GitDirectory, string WorkingTreeDirectory)? FindGitDir(this IFileSystem fileSystem, string path)`
`127`	`127`	`{`
`128`	`128`	`string? startingDir = path;`
`129`	`129`	`while (startingDir is not null)`
`130`	`130`	`{`
`131`	`131`	`var dirOrFilePath = PathHelper.Combine(startingDir, ".git");`
`132`		`- if (Directory.Exists(dirOrFilePath))`
	`132`	`+ if (fileSystem.DirectoryExists(dirOrFilePath))`
`133`	`133`	`{`
`134`	`134`	`return (dirOrFilePath, Path.GetDirectoryName(dirOrFilePath)!);`
`135`	`135`	`}`
`136`	`136`
`137`		`- if (File.Exists(dirOrFilePath))`
	`137`	`+ if (fileSystem.Exists(dirOrFilePath))`
`138`	`138`	`{`
`139`	`139`	`string? relativeGitDirPath = ReadGitDirFromFile(dirOrFilePath);`
`140`	`140`	`if (!string.IsNullOrWhiteSpace(relativeGitDirPath))`
`141`	`141`	`{`
`142`	`142`	`var fullGitDirPath = Path.GetFullPath(PathHelper.Combine(startingDir, relativeGitDirPath));`
`143`		`- if (Directory.Exists(fullGitDirPath))`
	`143`	`+ if (fileSystem.DirectoryExists(fullGitDirPath))`
`144`	`144`	`{`
`145`	`145`	`return (fullGitDirPath, Path.GetDirectoryName(dirOrFilePath)!);`
`146`	`146`	`}`