dependabot-nuget 0.287.0 → 0.288.0

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

@@ -0,0 +1,472 @@
+using System.Collections.Immutable;
+
+using NuGetUpdater.Core.Discover;
+using NuGetUpdater.Core.Test.Update;
+
+using Xunit;
+
+using TestFile = (string Path, string Content);
+
+namespace NuGetUpdater.Core.Test.Discover;
+
+public class SdkProjectDiscoveryTests : DiscoveryWorkerTestBase
+{
+    [Fact]
+    public async Task DiscoveryInSingleProject_TopLevelAndTransitive()
+    {
+        await TestDiscoverAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Top.Level.Package", "1.2.3", "net8.0", [("net8.0", [("Transitive.Dependency", "4.5.6")])]),
+                MockNuGetPackage.CreateSimplePackage("Transitive.Dependency", "4.5.6", "net8.0"),
+            ],
+            startingDirectory: "src",
+            projectPath: "src/library.csproj",
+            files:
+            [
+                ("src/library.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Top.Level.Package" Version="1.2.3" />
+                      </ItemGroup>
+                    </Project>
+                    """)
+            ],
+            expectedProjects:
+            [
+                new()
+                {
+                    FilePath = "library.csproj",
+                    Dependencies =
+                    [
+                        new("Top.Level.Package", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
+                        new("Transitive.Dependency", "4.5.6", DependencyType.Unknown, TargetFrameworks: ["net8.0"], IsTransitive: true)
+                    ],
+                    ImportedFiles = [],
+                    Properties =
+                    [
+                        new("TargetFramework", "net8.0", "src/library.csproj"),
+                    ],
+                    TargetFrameworks = ["net8.0"]
+                }
+            ]
+        );
+    }
+
+    [Fact]
+    public async Task DiscoveryInSingleProject_PackageAddedInTargetsFile()
+    {
+        await TestDiscoverAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Top.Level.Package", "1.2.3", "net8.0", [("net8.0", [("Transitive.Dependency", "4.5.6")])]),
+                MockNuGetPackage.CreateSimplePackage("Transitive.Dependency", "4.5.6", "net8.0"),
+            ],
+            startingDirectory: "src",
+            projectPath: "src/library.csproj",
+            files:
+            [
+                ("src/library.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                    </Project>
+                    """),
+                ("Directory.Build.targets", """
+                    <Project>
+                      <ItemGroup>
+                        <PackageReference Include="Top.Level.Package" Version="1.2.3" />
+                      </ItemGroup>
+                    </Project>
+                    """)
+            ],
+            expectedProjects:
+            [
+                new()
+                {
+                    FilePath = "library.csproj",
+                    Dependencies =
+                    [
+                        // dependencies come from `Directory.Build.targets`, but it's through the evaluation of `src/library.csproj` that it's found
+                        new("Top.Level.Package", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
+                        new("Transitive.Dependency", "4.5.6", DependencyType.Unknown, TargetFrameworks: ["net8.0"], IsTransitive: true)
+                    ],
+                    Properties =
+                    [
+                        new("TargetFramework", "net8.0", "src/library.csproj"),
+                    ],
+                    TargetFrameworks = ["net8.0"]
+                }
+            ]
+        );
+    }
+
+    [Fact]
+    public async Task DiscoveryThroughProjectReference()
+    {
+        await TestDiscoverAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Top.Level.Package", "1.2.3", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Dependency.From.Other.Project", "4.5.6", "net8.0"),
+            ],
+            startingDirectory: "src/library1",
+            projectPath: "src/library1/library1.csproj",
+            files:
+            [
+                ("src/library1/library1.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <ProjectReference Include="../library2/library2.csproj" />
+                      </ItemGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Top.Level.Package" Version="1.2.3" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+                ("src/library2/library2.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Dependency.From.Other.Project" Version="4.5.6" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+            ],
+            expectedProjects:
+            [
+                new()
+                {
+                    FilePath = "library1.csproj",
+                    Dependencies =
+                    [
+                        new("Top.Level.Package", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
+                        new("Dependency.From.Other.Project", "4.5.6", DependencyType.Unknown, TargetFrameworks: ["net8.0"], IsTransitive: true)
+                    ],
+                    ImportedFiles = [],
+                    ReferencedProjectPaths = [
+                        "../library2/library2.csproj"
+                    ],
+                    Properties =
+                    [
+                        new("TargetFramework", "net8.0", "src/library1/library1.csproj"),
+                    ],
+                    TargetFrameworks = ["net8.0"]
+                },
+                new()
+                {
+                    FilePath = "../library2/library2.csproj",
+                    Dependencies =
+                    [
+                        new("Dependency.From.Other.Project", "4.5.6", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true)
+                    ],
+                    Properties =
+                    [
+                        new("TargetFramework", "net8.0", "src/library2/library2.csproj"),
+                    ],
+                    TargetFrameworks = ["net8.0"]
+                }
+            ]
+        );
+    }
+
+    [Fact]
+    public async Task DiscoveryThroughProjectReferenceThroughTransitiveDependency()
+    {
+        await TestDiscoverAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Top.Level.Package", "1.2.3", "net8.0", [("net8.0", [("Transitive.Dependency", "4.5.6")])]),
+                MockNuGetPackage.CreateSimplePackage("Transitive.Dependency", "4.5.6", "net8.0"),
+            ],
+            startingDirectory: "src/library1",
+            projectPath: "src/library1/library1.csproj",
+            files:
+            [
+                ("src/library1/library1.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <ProjectReference Include="../library2/library2.csproj" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+                ("src/library2/library2.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Top.Level.Package" Version="1.2.3" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+            ],
+            expectedProjects:
+            [
+                new()
+                {
+                    FilePath = "library1.csproj",
+                    Dependencies =
+                    [
+                        // these are all transitive through the ProjectReference
+                        new("Top.Level.Package", "1.2.3", DependencyType.Unknown, TargetFrameworks: ["net8.0"], IsTransitive: true),
+                        new("Transitive.Dependency", "4.5.6", DependencyType.Unknown, TargetFrameworks: ["net8.0"], IsTransitive: true)
+                    ],
+                    ImportedFiles = [],
+                    ReferencedProjectPaths = [
+                        "../library2/library2.csproj",
+                    ],
+                    Properties =
+                    [
+                        new("TargetFramework", "net8.0", "src/library1/library1.csproj"),
+                    ],
+                    TargetFrameworks = ["net8.0"]
+                },
+                new()
+                {
+                    FilePath = "../library2/library2.csproj",
+                    Dependencies =
+                    [
+                        new("Top.Level.Package", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
+                        new("Transitive.Dependency", "4.5.6", DependencyType.Unknown, TargetFrameworks: ["net8.0"], IsTransitive: true)
+                    ],
+                    ImportedFiles = [],
+                    Properties =
+                    [
+                        new("TargetFramework", "net8.0", "src/library2/library2.csproj"),
+                    ],
+                    TargetFrameworks = ["net8.0"]
+                }
+            ]
+        );
+    }
+
+    [Fact]
+    public async Task DiscoverWithMultipleTargetFrameworks()
+    {
+        await TestDiscoverAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Dependency", "1.2.3", "net7.0"),
+            ],
+            startingDirectory: "src",
+            projectPath: "src/library.csproj",
+            files:
+            [
+                ("src/library.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFrameworks>net7.0;net8.0</TargetFrameworks>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Some.Dependency" Version="1.2.3" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+            ],
+            expectedProjects:
+            [
+                new()
+                {
+                    FilePath = "library.csproj",
+                    Dependencies =
+                    [
+                        new("Some.Dependency", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net7.0"], IsDirect: true),
+                        new("Some.Dependency", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
+                    ],
+                    ImportedFiles = [],
+                    Properties =
+                    [
+                        new("TargetFrameworks", "net7.0;net8.0", "src/library.csproj"),
+                    ],
+                    TargetFrameworks = ["net7.0", "net8.0"]
+                },
+            ]
+        );
+    }
+
+    [Fact]
+    public async Task DiscoveryIgnoresNetStandardLibrary()
+    {
+        await TestDiscoverAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Dependency", "1.2.3", "netstandard2.0"),
+            ],
+            startingDirectory: "src",
+            projectPath: "src/library.csproj",
+            files:
+            [
+                ("src/library.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>netstandard2.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Some.Dependency" Version="1.2.3" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+            ],
+            expectedProjects:
+            [
+                new()
+                {
+                    FilePath = "library.csproj",
+                    Dependencies =
+                    [
+                        new("Some.Dependency", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["netstandard2.0"], IsDirect: true),
+                    ],
+                    ImportedFiles = [],
+                    Properties =
+                    [
+                        new("TargetFramework", "netstandard2.0", "src/library.csproj"),
+                    ],
+                    TargetFrameworks = ["netstandard2.0"]
+                },
+            ]
+        );
+    }
+
+    [Fact]
+    public async Task GlobalPackages()
+    {
+        await TestDiscoverAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Dependency", "1.2.3", "netstandard2.0"),
+            ],
+            startingDirectory: "src",
+            projectPath: "src/library.csproj",
+            files:
+            [
+                ("src/library.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                        <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+                      </PropertyGroup>
+                    </Project>
+                    """),
+                ("src/Directory.Build.props", """
+                    <Project>
+                      <ItemGroup>
+                        <GlobalPackageReference Include="Some.Dependency" Version="1.2.3" />
+                      </ItemGroup>
+                    </Project>
+                    """)
+            ],
+            expectedProjects:
+            [
+                new()
+                {
+                    FilePath = "library.csproj",
+                    Dependencies =
+                    [
+                        new("Some.Dependency", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
+                    ],
+                    ImportedFiles =
+                    [
+                        "Directory.Build.props",
+                    ],
+                    Properties =
+                    [
+                        new("ManagePackageVersionsCentrally", "true", "src/library.csproj"),
+                        new("TargetFramework", "net8.0", "src/library.csproj"),
+                    ],
+                    TargetFrameworks = ["net8.0"]
+                },
+            ]
+        );
+    }
+
+    [Fact]
+    public async Task CentralPackageManagementAlternatePackagesPropsLocation()
+    {
+        // when using central package management, the well-known file `Directory.Packages.props` can be overridden with
+        // the `$(DirectoryPackagesPropsPath)` property
+        await TestDiscoverAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Dependency", "1.2.3", "netstandard2.0"),
+            ],
+            startingDirectory: "src",
+            projectPath: "src/library.csproj",
+            files:
+            [
+                ("src/library.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                        <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Some.Dependency" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+                ("src/Directory.Build.props", """
+                    <Project>
+                      <PropertyGroup>
+                        <DirectoryPackagesPropsPath>$(MSBuildThisFileDirectory)..\NonStandardPackages.props</DirectoryPackagesPropsPath>
+                      </PropertyGroup>
+                    </Project>
+                    """),
+                ("NonStandardPackages.props", """
+                    <Project>
+                      <ItemGroup>
+                        <PackageVersion Include="Some.Dependency" Version="1.2.3" />
+                      </ItemGroup>
+                    </Project>
+                    """)
+            ],
+            expectedProjects:
+            [
+                new()
+                {
+                    FilePath = "library.csproj",
+                    Dependencies =
+                    [
+                        new("Some.Dependency", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
+                    ],
+                    ImportedFiles =
+                    [
+                        "../NonStandardPackages.props",
+                        "Directory.Build.props",
+                    ],
+                    Properties =
+                    [
+                        new("ManagePackageVersionsCentrally", "true", "src/library.csproj"),
+                        new("TargetFramework", "net8.0", "src/library.csproj"),
+                    ],
+                    TargetFrameworks = ["net8.0"]
+                },
+            ]
+        );
+    }
+
+    private static async Task TestDiscoverAsync(string startingDirectory, string projectPath, TestFile[] files, ImmutableArray<ExpectedSdkProjectDiscoveryResult> expectedProjects, MockNuGetPackage[]? packages = null)
+    {
+        using var testDirectory = await TemporaryDirectory.CreateWithContentsAsync(files);
+
+        await UpdateWorkerTestBase.MockNuGetPackagesInDirectory(packages, testDirectory.DirectoryPath);
+
+        var logger = new TestLogger();
+        var fullProjectPath = Path.Combine(testDirectory.DirectoryPath, projectPath);
+        var experimentsManager = new ExperimentsManager() { UseDirectDiscovery = true }; // the following method is direct discovery; this just makes the call to Validate... happy
+        var projectDiscovery = await SdkProjectDiscovery.DiscoverWithBinLogAsync(testDirectory.DirectoryPath, Path.GetDirectoryName(fullProjectPath)!, fullProjectPath, logger);
+        ValidateProjectResults(expectedProjects, projectDiscovery, experimentsManager);
+    }
+}

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

@@ -291,9 +291,12 @@ namespace NuGetUpdater.Core.Test
                     <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
                         <!-- this is a simplified version of this package used for testing -->
                         <PropertyGroup>
-                        <CentralPackagesFile Condition=" '$(CentralPackagesFile)' == '' ">$([MSBuild]::GetPathOfFileAbove('Packages.props', $(MSBuildProjectDirectory)))</CentralPackagesFile>
+                          <CentralPackagesFile Condition=" '$(CentralPackagesFile)' == '' ">$([MSBuild]::GetPathOfFileAbove('Packages.props', $(MSBuildProjectDirectory)))</CentralPackagesFile>
                         </PropertyGroup>
                         <Import Project="$(CentralPackagesFile)" Condition="Exists('$(CentralPackagesFile)')" />
+                        <ItemGroup Condition=" '$(EnableGlobalPackageReferences)' != 'false' ">
+                          <PackageReference Include="@(GlobalPackageReference)" Condition=" '$(EnableGlobalPackageReferences)' != 'false' " />
+                        </ItemGroup>
                     </Project>
                     """
             );
@@ -384,6 +387,47 @@ namespace NuGetUpdater.Core.Test
             return WellKnownPackages[key];
         }
 
+        public static MockNuGetPackage WellKnownHostPackage(string packageName, string targetFramework, (string Path, byte[] Content)[]? files = null)
+        {
+            string key = $"{packageName}/{targetFramework}";
+            if (!WellKnownPackages.ContainsKey(key))
+            {
+                // for the current SDK, the file `Microsoft.NETCoreSdk.BundledVersions.props` contains the version of the
+                // `Microsoft.WindowsDesktop.App.Ref` package that will be needed to build, so we find it by TFM
+                XDocument propsDocument = XDocument.Load(BundledVersionsPropsPath.Value);
+                XElement? ridElement = propsDocument.XPathSelectElement("/Project/PropertyGroup/NETCoreSdkRuntimeIdentifier");
+                if (ridElement is null)
+                {
+                    throw new Exception($"Unable to find RID property.");
+                }
+
+                string expectedRid = ridElement.Value.Trim();
+
+                XElement? matchingAppHostPack = propsDocument.XPathSelectElement(
+                    $"""
+                    /Project/ItemGroup/KnownAppHostPack
+                        [
+                            @Include='{packageName}' and
+                            @AppHostPackNamePattern='{packageName}.Host.**RID**' and
+                            @TargetFramework='{targetFramework}'
+                        ]
+                    """);
+                if (matchingAppHostPack is null)
+                {
+                    throw new Exception($"Unable to find {packageName}.Host.**RID** version for target framework '{targetFramework}'");
+                }
+
+                string expectedVersion = matchingAppHostPack.Attribute("AppHostPackVersion")!.Value;
+                return new(
+                    $"{packageName}.Host.{expectedRid}",
+                    expectedVersion,
+                    Files: files
+                );
+            }
+
+            return WellKnownPackages[key];
+        }
+
         public static MockNuGetPackage[] CommonPackages { get; } =
         [
             CreateSimplePackage("NETStandard.Library", "2.0.3", "netstandard2.0"),
@@ -424,6 +468,7 @@ namespace NuGetUpdater.Core.Test
             WellKnownReferencePackage("Microsoft.WindowsDesktop.App", "net7.0"),
             WellKnownReferencePackage("Microsoft.WindowsDesktop.App", "net8.0"),
             WellKnownReferencePackage("Microsoft.WindowsDesktop.App", "net9.0"),
+            WellKnownHostPackage("Microsoft.NETCore.App", "net8.0"),
         ];
     }
 }

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

@@ -11,7 +11,6 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="DiffPlex" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="xunit" />

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Run/RunWorkerTests.cs

@@ -1429,7 +1429,7 @@ public class RunWorkerTests
         experimentsManager ??= new ExperimentsManager();
         var testApiHandler = new TestApiHandler();
         var logger = new TestLogger();
-        discoveryWorker ??= new DiscoveryWorker(logger);
+        discoveryWorker ??= new DiscoveryWorker(experimentsManager, logger);
         analyzeWorker ??= new AnalyzeWorker(logger);
         updaterWorker ??= new UpdaterWorker(experimentsManager, logger);
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Run/SerializationTests.cs

@@ -59,6 +59,34 @@ public class SerializationTests
         Assert.Equal("specific-sdk", jobWrapper.Job.Source.Directory);
     }
 
+    [Fact]
+    public void DeserializeJob_DebugIsNull()
+    {
+        // the `debug` field is defined as a `bool`, but can appear as `null` in the wild
+        var jobContent = """
+            {
+              "job": {
+                "package-manager": "nuget",
+                "allowed-updates": [
+                  {
+                    "update-type": "all"
+                  }
+                ],
+                "source": {
+                  "provider": "github",
+                  "repo": "some-org/some-repo",
+                  "directory": "specific-sdk",
+                  "hostname": null,
+                  "api-endpoint": null
+                },
+                "debug": null
+              }
+            }
+            """;
+        var jobWrapper = RunWorker.Deserialize(jobContent);
+        Assert.False(jobWrapper.Job.Debug);
+    }
+
     [Fact]
     public void DeserializeJob_FieldsNotYetSupported()
     {
@@ -125,6 +153,7 @@ public class SerializationTests
                 },
                 "experiments": {
                   "nuget_legacy_dependency_solver": true,
+                  "nuget_use_direct_discovery": true,
                   "unexpected_bool": true,
                   "unexpected_number": 42,
                   "unexpected_null": null,
@@ -140,6 +169,7 @@ public class SerializationTests
             """);
         var experimentsManager = ExperimentsManager.GetExperimentsManager(jobWrapper.Job.Experiments);
         Assert.True(experimentsManager.UseLegacyDependencySolver);
+        Assert.True(experimentsManager.UseDirectDiscovery);
     }
 
     [Fact]
@@ -166,6 +196,7 @@ public class SerializationTests
             """);
         var experimentsManager = ExperimentsManager.GetExperimentsManager(jobWrapper.Job.Experiments);
         Assert.False(experimentsManager.UseLegacyDependencySolver);
+        Assert.False(experimentsManager.UseDirectDiscovery);
     }
 
     [Fact]
@@ -190,6 +221,7 @@ public class SerializationTests
             """);
         var experimentsManager = ExperimentsManager.GetExperimentsManager(jobWrapper.Job.Experiments);
         Assert.False(experimentsManager.UseLegacyDependencySolver);
+        Assert.False(experimentsManager.UseDirectDiscovery);
     }
 
     [Fact]
@@ -212,6 +244,7 @@ public class SerializationTests
 
         // assert
         Assert.False(experimentsManager.UseLegacyDependencySolver);
+        Assert.False(experimentsManager.UseDirectDiscovery);
         Assert.Single(capturingTestLogger.Messages.Where(m => m.Contains("Error deserializing job file")));
     }
 

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

@@ -50,14 +50,15 @@ public sealed class TemporaryDirectory : IDisposable
         var parentDirectory = Path.GetDirectoryName(temporaryDirectory.DirectoryPath)!;
 
         // prevent directory crawling
-        await File.WriteAllTextAsync(Path.Combine(parentDirectory, "Directory.Build.props"), """
+        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>
               <PropertyGroup>
                 <ManagePackageVersionsCentrally>false</ManagePackageVersionsCentrally>
               </PropertyGroup>
             </Project>
             """);
-        await File.WriteAllTextAsync(Path.Combine(parentDirectory, "Directory.Build.targets"), "<Project />");
 
         foreach (var (path, contents) in fileContents)
         {

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

@@ -263,8 +263,9 @@ public abstract class UpdateWorkerTestBase : TestBase
         AssertContainsFiles(expectedResult, actualResult);
     }
 
-    public static async Task MockJobFileInDirectory(string temporaryDirectory)
+    public static async Task MockJobFileInDirectory(string temporaryDirectory, ExperimentsManager? experimentsManager = null)
     {
+        experimentsManager ??= new ExperimentsManager();
         var jobFile = new JobFile()
         {
             Job = new()
@@ -278,7 +279,8 @@ public abstract class UpdateWorkerTestBase : TestBase
                     Provider = "github",
                     Repo = "test/repo",
                     Directory = "/",
-                }
+                },
+                Experiments = experimentsManager.ToDictionary(),
             }
         };
         await File.WriteAllTextAsync(Path.Join(temporaryDirectory, "job.json"), JsonSerializer.Serialize(jobFile, RunWorker.SerializerOptions));