dependabot-nuget 0.251.0 → 0.252.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Discover/DiscoveryWorkerTests.cs

@@ -0,0 +1,306 @@
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Discover;
+
+public partial class DiscoveryWorkerTests : DiscoveryWorkerTestBase
+{
+    [Theory]
+    [InlineData("src/project.csproj")]
+    [InlineData("src/project.vbproj")]
+    [InlineData("src/project.fsproj")]
+    public async Task TestProjectFiles(string projectPath)
+    {
+        await TestDiscoveryAsync(
+            workspacePath: "src",
+            files: new[]
+            {
+                (projectPath, """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>netstandard2.0</TargetFramework>
+                        <NewtonsoftJsonPackageVersion>9.0.1</NewtonsoftJsonPackageVersion>
+                      </PropertyGroup>
+
+                      <ItemGroup>
+                        <PackageReference Include="Newtonsoft.Json" Version="$(NewtonsoftJsonPackageVersion)" />
+                      </ItemGroup>
+                    </Project>
+                    """)
+            },
+            expectedResult: new()
+            {
+                FilePath = "src",
+                Projects = [
+                    new()
+                    {
+                        FilePath = Path.GetFileName(projectPath),
+                        TargetFrameworks = ["netstandard2.0"],
+                        ReferencedProjectPaths = [],
+                        ExpectedDependencyCount = 19,
+                        Dependencies = [
+                            new("Microsoft.NET.Sdk", null, DependencyType.MSBuildSdk),
+                            new("Newtonsoft.Json", "9.0.1", DependencyType.PackageReference, TargetFrameworks: ["netstandard2.0"], IsDirect: true)
+                        ],
+                        Properties = [
+                            new("NewtonsoftJsonPackageVersion", "9.0.1", projectPath),
+                            new("TargetFramework", "netstandard2.0", projectPath),
+                        ]
+                    }
+                ]
+            }
+        );
+    }
+
+    [Fact]
+    public async Task TestPackageConfig()
+    {
+        var projectPath = "src/project.csproj";
+        await TestDiscoveryAsync(
+            workspacePath: "",
+            files: new[]
+            {
+                (projectPath, """
+                    <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+                      <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+                      <PropertyGroup>
+                        <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <None Include="packages.config" />
+                      </ItemGroup>
+                      <ItemGroup>
+                        <Reference Include="Newtonsoft.Json, Version=7.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+                          <HintPath>packages\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+                          <Private>True</Private>
+                        </Reference>
+                      </ItemGroup>
+                      <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                    </Project>
+                    """),
+                ("src/packages.config", """
+                    <packages>
+                      <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net45" />
+                    </packages>
+                    """),
+            },
+            expectedResult: new()
+            {
+                FilePath = "",
+                Projects = [
+                    new()
+                    {
+                        FilePath = projectPath,
+                        TargetFrameworks = ["net45"],
+                        ReferencedProjectPaths = [],
+                        ExpectedDependencyCount = 2, // Should we ignore Microsoft.NET.ReferenceAssemblies?
+                        Dependencies = [
+                            new("Newtonsoft.Json", "7.0.1", DependencyType.PackagesConfig, TargetFrameworks: ["net45"])
+                        ],
+                        Properties = [
+                            new("TargetFrameworkVersion", "v4.5", projectPath),
+                        ]
+                    }
+                ]
+            }
+        );
+    }
+
+    [Fact]
+    public async Task TestProps()
+    {
+        var projectPath = "src/project.csproj";
+        await TestDiscoveryAsync(
+            workspacePath: "",
+            files: new[]
+            {
+                (projectPath, """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>netstandard2.0</TargetFramework>
+                      </PropertyGroup>
+
+                      <ItemGroup>
+                        <PackageReference Include="Newtonsoft.Json" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+                ("Directory.Packages.props", """
+                    <Project>
+                      <PropertyGroup>
+                        <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+                        <NewtonsoftJsonPackageVersion>9.0.1</NewtonsoftJsonPackageVersion>
+                      </PropertyGroup>
+
+                      <ItemGroup>
+                        <PackageVersion Include="Newtonsoft.Json" Version="$(NewtonsoftJsonPackageVersion)" />
+                      </ItemGroup>
+                    </Project>
+                    """)
+            },
+            expectedResult: new()
+            {
+                FilePath = "",
+                Projects = [
+                    new()
+                    {
+                        FilePath = projectPath,
+                        TargetFrameworks = ["netstandard2.0"],
+                        ReferencedProjectPaths = [],
+                        ExpectedDependencyCount = 19,
+                        Dependencies = [
+                            new("Microsoft.NET.Sdk", null, DependencyType.MSBuildSdk),
+                            new("Newtonsoft.Json", "9.0.1", DependencyType.PackageReference, TargetFrameworks: ["netstandard2.0"], IsDirect: true)
+                        ],
+                        Properties = [
+                            new("ManagePackageVersionsCentrally", "true", "Directory.Packages.props"),
+                            new("NewtonsoftJsonPackageVersion", "9.0.1", "Directory.Packages.props"),
+                            new("TargetFramework", "netstandard2.0", projectPath),
+                        ]
+                    }
+                ],
+                DirectoryPackagesProps = new()
+                {
+                    FilePath = "Directory.Packages.props",
+                    Dependencies = [
+                        new("Newtonsoft.Json", "9.0.1", DependencyType.PackageVersion, IsDirect: true)
+                    ],
+                }
+            }
+        );
+    }
+
+    [Fact]
+    public async Task TestRepo()
+    {
+        var solutionPath = "solution.sln";
+        await TestDiscoveryAsync(
+            workspacePath: "",
+            files: new[]
+            {
+                ("src/project.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFrameworks>netstandard2.0;net6.0</TargetFrameworks>
+                      </PropertyGroup>
+
+                      <ItemGroup>
+                        <PackageReference Include="Newtonsoft.Json" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+                ("Directory.Packages.props", """
+                    <Project>
+                      <PropertyGroup>
+                        <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+                        <NewtonsoftJsonPackageVersion>9.0.1</NewtonsoftJsonPackageVersion>
+                      </PropertyGroup>
+
+                      <ItemGroup>
+                        <PackageVersion Include="Newtonsoft.Json" Version="$(NewtonsoftJsonPackageVersion)" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+                (solutionPath, """
+                    Microsoft Visual Studio Solution File, Format Version 12.00
+                    # Visual Studio 14
+                    VisualStudioVersion = 14.0.22705.0
+                    MinimumVisualStudioVersion = 10.0.40219.1
+                    Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "project", ".\src\project.csproj", "{782E0C0A-10D3-444D-9640-263D03D2B20C}"
+                    EndProject
+                    Global
+                      GlobalSection(SolutionConfigurationPlatforms) = preSolution
+                        Debug|Any CPU = Debug|Any CPU
+                        Release|Any CPU = Release|Any CPU
+                      EndGlobalSection
+                      GlobalSection(ProjectConfigurationPlatforms) = postSolution
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Release|Any CPU.Build.0 = Release|Any CPU
+                      EndGlobalSection
+                      GlobalSection(SolutionProperties) = preSolution
+                        HideSolutionNode = FALSE
+                      EndGlobalSection
+                    EndGlobal
+                    """),
+                ("global.json", """
+                    {
+                      "sdk": {
+                        "version": "6.0.405",
+                        "rollForward": "latestPatch"
+                      },
+                      "msbuild-sdks": {
+                        "My.Custom.Sdk": "5.0.0",
+                        "My.Other.Sdk": "1.0.0-beta"
+                      }
+                    }
+                    """),
+                (".config/dotnet-tools.json", """
+                    {
+                      "version": 1,
+                      "isRoot": true,
+                      "tools": {
+                        "microsoft.botsay": {
+                          "version": "1.0.0",
+                          "commands": [
+                            "botsay"
+                          ]
+                        },
+                        "dotnetsay": {
+                          "version": "2.1.3",
+                          "commands": [
+                            "dotnetsay"
+                          ]
+                        }
+                      }
+                    }
+                    """),
+            },
+            expectedResult: new()
+            {
+                FilePath = "",
+                Projects = [
+                    new()
+                    {
+                        FilePath = "src/project.csproj",
+                        TargetFrameworks = ["net6.0", "netstandard2.0"],
+                        ExpectedDependencyCount = 19,
+                        Dependencies = [
+                            new("Microsoft.NET.Sdk", null, DependencyType.MSBuildSdk),
+                            new("Newtonsoft.Json", "9.0.1", DependencyType.PackageReference, TargetFrameworks: ["net6.0", "netstandard2.0"], IsDirect: true)
+                        ],
+                        Properties = [
+                            new("ManagePackageVersionsCentrally", "true", "Directory.Packages.props"),
+                            new("NewtonsoftJsonPackageVersion", "9.0.1", "Directory.Packages.props"),
+                            new("TargetFrameworks", "netstandard2.0;net6.0", "src/project.csproj"),
+                        ]
+                    }
+                ],
+                DirectoryPackagesProps = new()
+                {
+                    FilePath = "Directory.Packages.props",
+                    Dependencies = [
+                        new("Newtonsoft.Json", "9.0.1", DependencyType.PackageVersion, IsDirect: true)
+                    ],
+                },
+                GlobalJson = new()
+                {
+                    FilePath = "global.json",
+                    Dependencies = [
+                        new("Microsoft.NET.Sdk", "6.0.405", DependencyType.MSBuildSdk),
+                        new("My.Custom.Sdk", "5.0.0", DependencyType.MSBuildSdk),
+                        new("My.Other.Sdk", "1.0.0-beta", DependencyType.MSBuildSdk),
+                    ]
+                },
+                DotNetToolsJson = new()
+                {
+                    FilePath = ".config/dotnet-tools.json",
+                    Dependencies = [
+                        new("microsoft.botsay", "1.0.0", DependencyType.DotNetTool),
+                        new("dotnetsay", "2.1.3", DependencyType.DotNetTool),
+                    ]
+                }
+            }
+        );
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Discover/ExpectedDiscoveryResults.cs

@@ -0,0 +1,36 @@
+using System.Collections.Immutable;
+
+using NuGetUpdater.Core.Discover;
+
+namespace NuGetUpdater.Core.Test.Discover;
+
+public record ExpectedWorkspaceDiscoveryResult : IDiscoveryResult
+{
+    public required string FilePath { get; init; }
+    public bool IsSuccess { get; init; } = true;
+    public ImmutableArray<ExpectedSdkProjectDiscoveryResult> Projects { get; init; }
+    public int? ExpectedProjectCount { get; init; }
+    public ExpectedDirectoryPackagesPropsDiscovertyResult? DirectoryPackagesProps { get; init; }
+    public ExpectedDependencyDiscoveryResult? GlobalJson { get; init; }
+    public ExpectedDependencyDiscoveryResult? DotNetToolsJson { get; init; }
+}
+
+public record ExpectedDirectoryPackagesPropsDiscovertyResult : ExpectedDependencyDiscoveryResult
+{
+    public bool IsTransitivePinningEnabled { get; init; }
+}
+
+public record ExpectedSdkProjectDiscoveryResult : ExpectedDependencyDiscoveryResult
+{
+    public ImmutableArray<Property> Properties { get; init; } = [];
+    public ImmutableArray<string> TargetFrameworks { get; init; } = [];
+    public ImmutableArray<string> ReferencedProjectPaths { get; init; } = [];
+}
+
+public record ExpectedDependencyDiscoveryResult : IDiscoveryResultWithDependencies
+{
+    public required string FilePath { get; init; }
+    public bool IsSuccess { get; init; } = true;
+    public ImmutableArray<Dependency> Dependencies { get; init; }
+    public int? ExpectedDependencyCount { get; init; }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/DotNetToolsJsonBuildFileTests.cs

@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
 using Xunit;
@@ -30,7 +29,7 @@ public class DotnetToolsJsonBuildFileTests
         """;
 
     private static DotNetToolsJsonBuildFile GetBuildFile() => new(
-        repoRootPath: "/",
+        basePath: "/",
         path: "/.config/dotnet-tools.json",
         contents: DotnetToolsJson,
         logger: new Logger(verbose: true));

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/GlobalJsonBuildFileTests.cs

@@ -1,6 +1,4 @@
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 
 using Xunit;
 
@@ -29,7 +27,7 @@ public class GlobalJsonBuildFileTests
         """;
 
     private static GlobalJsonBuildFile GetBuildFile(string contents) => new(
-        repoRootPath: "/",
+        basePath: "/",
         path: "/global.json",
         contents: contents,
         logger: new Logger(verbose: true));
@@ -55,6 +53,7 @@ public class GlobalJsonBuildFileTests
     {
         var expectedDependencies = new List<Dependency>
         {
+            new("Microsoft.NET.Sdk", "6.0.405", DependencyType.MSBuildSdk),
             new("My.Custom.Sdk", "5.0.0", DependencyType.MSBuildSdk),
             new("My.Other.Sdk", "1.0.0-beta", DependencyType.MSBuildSdk)
         };

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/PackagesConfigBuildFileTests.cs

@@ -1,6 +1,4 @@
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 
 using Microsoft.Language.Xml;
 
@@ -28,7 +26,7 @@ public class PackagesConfigBuildFileTests
         """;
 
     private static PackagesConfigBuildFile GetBuildFile(string contents) => new(
-        repoRootPath: "/",
+        basePath: "/",
         path: "/packages.config",
         contents: Parser.ParseText(contents));
 
@@ -37,9 +35,9 @@ public class PackagesConfigBuildFileTests
     {
         var expectedDependencies = new List<Dependency>
         {
-            new("Microsoft.CodeDom.Providers.DotNetCompilerPlatform", "1.0.0", DependencyType.PackageConfig),
-            new("Microsoft.Net.Compilers", "1.0.0", DependencyType.PackageConfig, true),
-            new("Newtonsoft.Json", "8.0.3", DependencyType.PackageConfig)
+            new("Microsoft.CodeDom.Providers.DotNetCompilerPlatform", "1.0.0", DependencyType.PackagesConfig),
+            new("Microsoft.Net.Compilers", "1.0.0", DependencyType.PackagesConfig, IsDevDependency: true),
+            new("Newtonsoft.Json", "8.0.3", DependencyType.PackagesConfig)
         };
 
         var buildFile = GetBuildFile(PackagesConfig);

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/ProjectBuildFileTests.cs

@@ -1,10 +1,10 @@
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using System.Text.RegularExpressions;
 
 using Microsoft.Language.Xml;
 
+using NuGetUpdater.Core.Test.Utilities;
+
 using Xunit;
 
 namespace NuGetUpdater.Core.Test.Files;
@@ -50,7 +50,7 @@ public class ProjectBuildFileTests
         """;
 
     private static ProjectBuildFile GetBuildFile(string contents, string filename) => new(
-        repoRootPath: "/",
+        basePath: "/",
         path: $"/{filename}",
         contents: Parser.ParseText(contents));
 
@@ -59,16 +59,17 @@ public class ProjectBuildFileTests
     {
         var expectedDependencies = new List<Dependency>
         {
+            new("Microsoft.NET.Sdk", null, DependencyType.MSBuildSdk),
             new("GuiLabs.Language.Xml", "1.2.60", DependencyType.PackageReference),
             new("Microsoft.CodeAnalysis.CSharp", null, DependencyType.PackageReference),
-            new("Newtonsoft.Json", "13.0.3", DependencyType.PackageReference, IsOverride: true)
+            new("Newtonsoft.Json", "13.0.3", DependencyType.PackageReference, IsUpdate: true, IsOverride: true)
         };
 
         var buildFile = GetBuildFile(ProjectCsProj, "Project.csproj");
 
         var dependencies = buildFile.GetDependencies();
 
-        Assert.Equal(expectedDependencies, dependencies);
+        AssertEx.Equal(expectedDependencies, dependencies);
     }
 
     [Fact]

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/NuGetUpdater.Core.Test.csproj

@@ -11,9 +11,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
-    <PackageReference Include="xunit" Version="2.4.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
+    <PackageReference Include="DiffPlex" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio" />
   </ItemGroup>
 
   <ItemGroup>

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/TemporaryDirectory.cs

@@ -1,8 +1,7 @@
-using System;
-using System.IO;
-
 namespace NuGetUpdater.Core.Test;
 
+using TestFile = (string Path, string Contents);
+
 public sealed class TemporaryDirectory : IDisposable
 {
     public string DirectoryPath { get; }
@@ -20,15 +19,48 @@ public sealed class TemporaryDirectory : IDisposable
         Directory.Delete(DirectoryPath, true);
     }
 
-    public static TemporaryDirectory CreateWithContents(params (string Path, string Contents)[] fileContents)
+    public async Task<TestFile[]> ReadFileContentsAsync(HashSet<string> filePaths)
+    {
+        var files = new List<(string Path, string Content)>();
+        foreach (var file in Directory.GetFiles(DirectoryPath, "*.*", SearchOption.AllDirectories))
+        {
+            var localPath = file.StartsWith(DirectoryPath)
+                ? file[DirectoryPath.Length..]
+                : file; // how did this happen?
+            localPath = localPath.NormalizePathToUnix();
+            if (localPath.StartsWith('/'))
+            {
+                localPath = localPath[1..];
+            }
+
+            if (filePaths.Contains(localPath))
+            {
+                var content = await File.ReadAllTextAsync(file);
+                files.Add((localPath, content));
+            }
+        }
+
+        return files.ToArray();
+    }
+
+    public static async Task<TemporaryDirectory> CreateWithContentsAsync(params TestFile[] fileContents)
     {
         var temporaryDirectory = new TemporaryDirectory();
+
+        var parentDirectory = Path.GetDirectoryName(temporaryDirectory.DirectoryPath)!;
+
+        // prevent directory crawling
+        await File.WriteAllTextAsync(Path.Combine(parentDirectory, "Directory.Build.props"), "<Project />");
+        await File.WriteAllTextAsync(Path.Combine(parentDirectory, "Directory.Build.targets"), "<Project />");
+        await File.WriteAllTextAsync(Path.Combine(parentDirectory, "Directory.Packages.props"), "<Project />");
+
         foreach (var (path, contents) in fileContents)
         {
-            var fullPath = Path.Combine(temporaryDirectory.DirectoryPath, path);
+            var localPath = path.StartsWith('/') ? path[1..] : path; // remove path rooting character
+            var fullPath = Path.Combine(temporaryDirectory.DirectoryPath, localPath);
             var fullDirectory = Path.GetDirectoryName(fullPath)!;
             Directory.CreateDirectory(fullDirectory);
-            File.WriteAllText(fullPath, contents);
+            await File.WriteAllTextAsync(fullPath, contents);
         }
 
         return temporaryDirectory;

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTestBase.cs

@@ -1,16 +1,15 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 using Xunit;
 
-using TestFile = (string Path, string Content);
-using TestProject = (string Path, string Content, System.Guid ProjectId);
-
 namespace NuGetUpdater.Core.Test.Update;
 
+using TestFile = (string Path, string Content);
+using TestProject = (string Path, string Content, Guid ProjectId);
+
 public abstract class UpdateWorkerTestBase
 {
     protected static Task TestNoChange(
@@ -20,7 +19,7 @@ public abstract class UpdateWorkerTestBase
         bool useSolution,
         string projectContents,
         bool isTransitive = false,
-        (string Path, string Content)[]? additionalFiles = null,
+        TestFile[]? additionalFiles = null,
         string projectFilePath = "test-project.csproj")
     {
         return useSolution
@@ -67,7 +66,7 @@ public abstract class UpdateWorkerTestBase
         string newVersion,
         string projectContents,
         bool isTransitive = false,
-        (string Path, string Content)[]? additionalFiles = null,
+        TestFile[]? additionalFiles = null,
         string projectFilePath = "test-project.csproj")
         => TestUpdateForProject(
             dependencyName,
@@ -202,53 +201,26 @@ public abstract class UpdateWorkerTestBase
         AssertContainsFiles(expectedResult, actualResult);
     }
 
-    protected static async Task<(string Path, string Content)[]> RunUpdate((string Path, string Content)[] files, Func<string, Task> action)
+    protected static async Task<TestFile[]> RunUpdate(TestFile[] files, Func<string, Task> action)
     {
         // write initial files
-        using var tempDir = new TemporaryDirectory();
-        foreach (var file in files)
-        {
-            var localPath = file.Path.StartsWith('/') ? file.Path[1..] : file.Path; // remove path rooting character
-            var filePath = Path.Combine(tempDir.DirectoryPath, localPath);
-            var directoryPath = Path.GetDirectoryName(filePath);
-            Directory.CreateDirectory(directoryPath!);
-            await File.WriteAllTextAsync(filePath, file.Content);
-        }
+        using var temporaryDirectory = await TemporaryDirectory.CreateWithContentsAsync(files);
 
         // run update
-        await action(tempDir.DirectoryPath);
+        await action(temporaryDirectory.DirectoryPath);
 
         // gather results
-        var expectedFiles = new HashSet<string>(files.Select(f => f.Path));
-        var result = new List<(string Path, string Content)>();
-        foreach (var file in Directory.GetFiles(tempDir.DirectoryPath, "*.*", SearchOption.AllDirectories))
-        {
-            var localPath = file.StartsWith(tempDir.DirectoryPath)
-                ? file[tempDir.DirectoryPath.Length..]
-                : file; // how did this happen?
-            localPath = localPath.NormalizePathToUnix();
-            if (localPath.StartsWith('/'))
-            {
-                localPath = localPath[1..];
-            }
-
-            if (expectedFiles.Contains(localPath))
-            {
-                var content = await File.ReadAllTextAsync(file);
-                result.Add((localPath, content));
-            }
-        }
-
-        return result.ToArray();
+        var filePaths = files.Select(f => f.Path).ToHashSet();
+        return await temporaryDirectory.ReadFileContentsAsync(filePaths);
     }
 
-    protected static void AssertEqualFiles((string Path, string Content)[] expected, (string Path, string Content)[] actual)
+    protected static void AssertEqualFiles(TestFile[] expected, TestFile[] actual)
     {
         Assert.Equal(expected.Length, actual.Length);
         AssertContainsFiles(expected, actual);
     }
 
-    protected static void AssertContainsFiles((string Path, string Content)[] expected, (string Path, string Content)[] actual)
+    protected static void AssertContainsFiles(TestFile[] expected, TestFile[] actual)
     {
         var actualContents = actual.ToDictionary(pair => pair.Path, pair => pair.Content);
         foreach (var expectedPair in expected)