dependabot-nuget 0.287.0 → 0.289.0

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,7 +244,8 @@ public class SerializationTests
 
         // assert
         Assert.False(experimentsManager.UseLegacyDependencySolver);
-        Assert.Single(capturingTestLogger.Messages.Where(m => m.Contains("Error deserializing job file")));
+        Assert.False(experimentsManager.UseDirectDiscovery);
+        Assert.Single(capturingTestLogger.Messages, m => m.Contains("Error deserializing job file"));
     }
 
     [Fact]
@@ -230,7 +263,7 @@ public class SerializationTests
 
         public IReadOnlyList<string> Messages => _messages;
 
-        public void Log(string message)
+        public void LogRaw(string message)
         {
             _messages.Add(message);
         }

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

@@ -40,6 +40,8 @@ public class UpdatedDependencyListTests
                     Properties = [],
                     TargetFrameworks = ["net8.0"],
                     ReferencedProjectPaths = [],
+                    ImportedFiles = [],
+                    AdditionalFiles = ["packages.config"],
                 },
                 new()
                 {
@@ -50,6 +52,8 @@ public class UpdatedDependencyListTests
                     Properties = [],
                     TargetFrameworks = ["net8.0"],
                     ReferencedProjectPaths = [],
+                    ImportedFiles = [],
+                    AdditionalFiles = ["packages.config"],
                 },
                 new()
                 {
@@ -62,6 +66,8 @@ public class UpdatedDependencyListTests
                     Properties = [],
                     TargetFrameworks = ["net8.0"],
                     ReferencedProjectPaths = [],
+                    ImportedFiles = [],
+                    AdditionalFiles = ["packages.config"],
                 }
             ]
         };
@@ -99,13 +105,65 @@ public class UpdatedDependencyListTests
                         new ReportedRequirement()
                         {
                             Requirement = "13.0.1",
-                            File = "/src/c/packages.config",
+                            File = "/src/c/project.csproj",
                             Groups = ["dependencies"],
                         },
                     ]
                 },
             ],
-            DependencyFiles = ["/src/a/project.csproj", "/src/b/project.csproj", "/src/c/project.csproj", "/src/a/packages.config", "/src/b/packages.config", "/src/c/packages.config"],
+            DependencyFiles = ["/src/a/packages.config", "/src/a/project.csproj", "/src/b/packages.config", "/src/b/project.csproj", "/src/c/packages.config", "/src/c/project.csproj"],
+        };
+
+        // doing JSON comparison makes this easier; we don't have to define custom record equality and we get an easy diff
+        var actualJson = JsonSerializer.Serialize(updatedDependencyList);
+        var expectedJson = JsonSerializer.Serialize(expectedDependencyList);
+        Assert.Equal(expectedJson, actualJson);
+    }
+
+    [Fact]
+    public async Task UpdatedDependencyListDeduplicatesFiles()
+    {
+        // arrange
+        using var tempDir = new TemporaryDirectory();
+        var testFiles = new[]
+        {
+            "Directory.Packages.props",
+            "project1/project1.csproj",
+            "project2/project2.csproj",
+        };
+        foreach (var testFile in testFiles)
+        {
+            var fullFilePath = Path.Join(tempDir.DirectoryPath, testFile);
+            Directory.CreateDirectory(Path.GetDirectoryName(fullFilePath)!);
+            await File.WriteAllTextAsync(fullFilePath, "");
+        }
+        var discovery = new WorkspaceDiscoveryResult()
+        {
+            Path = "",
+            Projects = [
+                new()
+                {
+                    FilePath = "project1/project1.csproj",
+                    Dependencies = [],
+                    ImportedFiles = ["../Directory.Packages.props"],
+                    AdditionalFiles = [],
+                },
+                new()
+                {
+                    FilePath = "project2/project2.csproj",
+                    Dependencies = [],
+                    ImportedFiles = ["../Directory.Packages.props"],
+                    AdditionalFiles = [],
+                }
+            ]
+        };
+
+        // act
+        var updatedDependencyList = RunWorker.GetUpdatedDependencyListFromDiscovery(discovery, pathToContents: tempDir.DirectoryPath);
+        var expectedDependencyList = new UpdatedDependencyList()
+        {
+            Dependencies = [],
+            DependencyFiles = ["/Directory.Packages.props", "/project1/project1.csproj", "/project2/project2.csproj"],
         };
 
         // doing JSON comparison makes this easier; we don't have to define custom record equality and we get an easy diff

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/TestLogger.cs

@@ -4,7 +4,7 @@ namespace NuGetUpdater.Core.Test;
 
 public class TestLogger : ILogger
 {
-    public void Log(string message)
+    public void LogRaw(string message)
     {
         Debug.WriteLine(message);
     }

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

@@ -2,7 +2,7 @@ using Xunit;
 
 namespace NuGetUpdater.Core.Test.Update;
 
-public class BindingRedirectsTests
+public class BindingRedirectsTests : TestBase
 {
     [Fact]
     public async Task SimpleBindingRedirectIsPerformed()

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

@@ -77,7 +77,8 @@ public abstract class UpdateWorkerTestBase : TestBase
         TestFile[]? additionalFiles = null,
         MockNuGetPackage[]? packages = null,
         ExperimentsManager? experimentsManager = null,
-        string projectFilePath = "test-project.csproj")
+        string projectFilePath = "test-project.csproj",
+        ExpectedUpdateOperationResult? expectedResult = null)
         => TestUpdateForProject(
             dependencyName,
             oldVersion,
@@ -88,7 +89,8 @@ public abstract class UpdateWorkerTestBase : TestBase
             additionalFiles,
             additionalFilesExpected: additionalFiles,
             packages: packages,
-            experimentsManager: experimentsManager);
+            experimentsManager: experimentsManager,
+            expectedResult: expectedResult);
 
     protected static Task TestUpdateForProject(
         string dependencyName,
@@ -263,8 +265,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 +281,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));

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.PackageReference.cs

@@ -3109,6 +3109,46 @@ public partial class UpdateWorkerTests
             );
         }
 
+        [Fact]
+        public async Task NoChange_IfPeerDependenciesCannotBeEvaluated()
+        {
+            // make sure we don't throw if we find conflicting peer dependencies; this can happen in multi-tfm projects if the dependencies are too complicated to resolve
+            // eventually this should be able to be resolved, but currently we can't branch on the different packages for different TFMs
+            await TestNoChangeforProject("Some.Package", "1.0.0", "1.1.0",
+                packages:
+                [
+                    // initial packages
+                    new MockNuGetPackage("Some.Package", "1.0.0",
+                        DependencyGroups: [
+                            ("net8.0", [("Transitive.Dependency", "8.0.0")]),
+                            ("net9.0", [("Transitive.Dependency", "9.0.0")])
+                        ]),
+                    MockNuGetPackage.CreateSimplePackage("Transitive.Dependency", "8.0.0", "net8.0"),
+                    MockNuGetPackage.CreateSimplePackage("Transitive.Dependency", "9.0.0", "net9.0"),
+
+                    // what we're trying to update to, but will fail
+                    new MockNuGetPackage("Some.Package", "1.1.0",
+                        DependencyGroups: [
+                            ("net8.0", [("Transitive.Dependency", "8.1.0")]),
+                            ("net9.0", [("Transitive.Dependency", "9.1.0")])
+                        ]),
+                    MockNuGetPackage.CreateSimplePackage("Transitive.Dependency", "8.1.0", "net8.0"),
+                    MockNuGetPackage.CreateSimplePackage("Transitive.Dependency", "9.1.0", "net9.0"),
+                ],
+                projectContents: """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Some.Package" Version="1.0.0" />
+                      </ItemGroup>
+                    </Project>
+                    """,
+                expectedResult: new() // success
+            );
+        }
+
         [Fact]
         public async Task ProcessingProjectWithWorkloadReferencesDoesNotFail()
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.PackagesConfig.cs

@@ -2294,7 +2294,7 @@ public partial class UpdateWorkerTests
             var resultContents = await File.ReadAllTextAsync(resultOutputPath);
             var result = JsonSerializer.Deserialize<UpdateOperationResult>(resultContents, UpdaterWorker.SerializerOptions)!;
             Assert.Equal(ErrorType.MissingFile, result.ErrorType);
-            Assert.Equal(Path.Combine(temporaryDirectory.DirectoryPath, "this.file.does.not.exist.targets"), result.ErrorDetails.ToString());
+            Assert.Equal(Path.Combine(temporaryDirectory.DirectoryPath, "this.file.does.not.exist.targets"), result.ErrorDetails!.ToString());
         }
 
         [Fact]

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/AssertEx.cs

@@ -97,7 +97,7 @@ public static class AssertEx
             return;
         }
 
-        Assert.True(false, GetAssertMessage(expected, actual, comparer, message));
+        Assert.Fail(GetAssertMessage(expected, actual, comparer, message));
     }
 
     private static bool SequenceEqual<T>(

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/LinuxOnlyAttribute.cs

@@ -0,0 +1,12 @@
+using Xunit;
+
+public class LinuxOnlyFactAttribute : FactAttribute
+{
+    public LinuxOnlyFactAttribute()
+    {
+        if (!OperatingSystem.IsLinux())
+        {
+            Skip = "This test runs only on Linux.";
+        }
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/MSBuildHelperTests.cs

@@ -172,7 +172,8 @@ public class MSBuildHelperTests : TestBase
             temp.DirectoryPath,
             temp.DirectoryPath,
             "netstandard2.0",
-            [new Dependency("Package.A", "1.0.0", DependencyType.Unknown)]
+            [new Dependency("Package.A", "1.0.0", DependencyType.Unknown)],
+            new TestLogger()
         );
         AssertEx.Equal(expectedDependencies, actualDependencies);
     }
@@ -300,7 +301,7 @@ public class MSBuildHelperTests : TestBase
             new Dependency("Package.2A", "1.0.0", DependencyType.Unknown),
             new Dependency("Package.2R", "18.0.0", DependencyType.Unknown),
         };
-        var actualDependencies = await MSBuildHelper.GetAllPackageDependenciesAsync(temp.DirectoryPath, temp.DirectoryPath, "net8.0", packages);
+        var actualDependencies = await MSBuildHelper.GetAllPackageDependenciesAsync(temp.DirectoryPath, temp.DirectoryPath, "net8.0", packages, new TestLogger());
         for (int i = 0; i < actualDependencies.Length; i++)
         {
             var ad = actualDependencies[i];
@@ -334,7 +335,7 @@ public class MSBuildHelperTests : TestBase
             new Dependency("Package.B", "2.0.0", DependencyType.Unknown, TargetFrameworks: ["net8.0"]),
             new Dependency("Package.C", "3.0.0", DependencyType.Unknown, IsUpdate: true)
         };
-        var actualDependencies = await MSBuildHelper.GetAllPackageDependenciesAsync(temp.DirectoryPath, temp.DirectoryPath, "net8.0", packages);
+        var actualDependencies = await MSBuildHelper.GetAllPackageDependenciesAsync(temp.DirectoryPath, temp.DirectoryPath, "net8.0", packages, new TestLogger());
         AssertEx.Equal(expectedDependencies, actualDependencies);
     }
 
@@ -371,7 +372,8 @@ public class MSBuildHelperTests : TestBase
                 temp.DirectoryPath,
                 temp.DirectoryPath,
                 "net8.0",
-                [new Dependency("Some.Package", "4.5.11", DependencyType.Unknown)]
+                [new Dependency("Some.Package", "4.5.11", DependencyType.Unknown)],
+                new TestLogger()
             );
         }
         finally
@@ -428,7 +430,8 @@ public class MSBuildHelperTests : TestBase
                 temp.DirectoryPath,
                 temp.DirectoryPath,
                 "net8.0",
-                [new Dependency("Package.A", "1.0.0", DependencyType.Unknown)]
+                [new Dependency("Package.A", "1.0.0", DependencyType.Unknown)],
+                new TestLogger()
             );
 
             AssertEx.Equal(expectedDependencies, actualDependencies);

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/PathHelperTests.cs

@@ -23,14 +23,60 @@ public class PathHelperTests
     [Fact]
     public void VerifyResolveCaseInsensitivePath()
     {
-        var temp = new TemporaryDirectory();
+        using var temp = new TemporaryDirectory();
         Directory.CreateDirectory(Path.Combine(temp.DirectoryPath, "src", "a"));
         File.WriteAllText(Path.Combine(temp.DirectoryPath, "src", "a", "packages.config"), "");
 
         var repoRootPath = Path.Combine(temp.DirectoryPath, "src");
 
-        var resolvedPath = PathHelper.ResolveCaseInsensitivePathInsideRepoRoot(Path.Combine(repoRootPath, "A", "PACKAGES.CONFIG"), repoRootPath);
+        var resolvedPath = PathHelper.ResolveCaseInsensitivePathsInsideRepoRoot(Path.Combine(repoRootPath, "A", "PACKAGES.CONFIG"), repoRootPath);
 
-        Assert.Equal(Path.Combine(temp.DirectoryPath, "src", "a", "packages.config"), resolvedPath);
+        var expected = Path.Combine(temp.DirectoryPath, "src", "a", "packages.config").NormalizePathToUnix();
+        Assert.Equal(expected, resolvedPath!.First());
+    }
+
+    [LinuxOnlyFact]
+    public void VerifyMultipleMatchingPathsReturnsAllPaths()
+    {
+        using var temp = new TemporaryDirectory();
+        Directory.CreateDirectory(Path.Combine(temp.DirectoryPath, "src", "a"));
+        Directory.CreateDirectory(Path.Combine(temp.DirectoryPath, "src", "A"));
+
+        File.WriteAllText(Path.Combine(temp.DirectoryPath, "src", "a", "packages.config"), "");
+        File.WriteAllText(Path.Combine(temp.DirectoryPath, "src", "A", "packages.config"), "");
+
+        var repoRootPath = Path.Combine(temp.DirectoryPath, "src");
+
+        var resolvedPaths = PathHelper.ResolveCaseInsensitivePathsInsideRepoRoot(Path.Combine(repoRootPath, "A", "PACKAGES.CONFIG"), repoRootPath);
+
+        var expected = new[]
+        {
+            Path.Combine(temp.DirectoryPath, "src", "a", "packages.config").NormalizePathToUnix(),
+            Path.Combine(temp.DirectoryPath, "src", "A", "packages.config").NormalizePathToUnix(),
+        };
+
+        Assert.Equal(expected, resolvedPaths!);
+    }
+
+    [LinuxOnlyFact]
+    public async void FilesWithDifferentlyCasedDirectoriesCanBeResolved()
+    {
+        // arrange
+        using var temp = new TemporaryDirectory();
+        var testFile1 = "src/project1/project1.csproj";
+        var testFile2 = "SRC/project2/project2.csproj";
+        var testFiles = new[] { testFile1, testFile2 };
+        foreach (var testFile in testFiles)
+        {
+            var fullPath = Path.Join(temp.DirectoryPath, testFile); Directory.CreateDirectory(Path.GetDirectoryName(fullPath)!);
+            await File.WriteAllTextAsync(fullPath, "");
+        }
+
+        // act        
+        var actualFile1 = PathHelper.ResolveCaseInsensitivePathsInsideRepoRoot(Path.Join(temp.DirectoryPath, testFile1), temp.DirectoryPath);
+        var actualFile2 = PathHelper.ResolveCaseInsensitivePathsInsideRepoRoot(Path.Join(temp.DirectoryPath, testFile2), temp.DirectoryPath);
+
+        // assert        
+        Assert.EndsWith(testFile1, actualFile1![0]); Assert.EndsWith(testFile2, actualFile2![0]);
     }
 }

data/lib/dependabot/nuget/analysis/analysis_json_reader.rb

@@ -14,7 +14,9 @@ module Dependabot
 
       sig { returns(String) }
       def self.temp_directory
-        File.join(NativeDiscoveryJsonReader.temp_directory, "analysis")
+        d = File.join(Dir.tmpdir, "analysis")
+        FileUtils.mkdir_p(d)
+        d
       end
 
       sig { params(dependency_name: String).returns(String) }