dependabot-nuget 0.302.0 → 0.304.0

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

@@ -1247,6 +1247,83 @@ public partial class DiscoveryWorkerTests : DiscoveryWorkerTestBase
         );
     }
 
+    [Fact]
+    public async Task ReportsPrivateSourceBadResponseFailure()
+    {
+        static (int, string) TestHttpHandler(string uriString)
+        {
+            var uri = new Uri(uriString, UriKind.Absolute);
+            var baseUrl = $"{uri.Scheme}://{uri.Host}:{uri.Port}";
+            return uri.PathAndQuery switch
+            {
+                // initial request is good
+                "/index.json" => (200, $$"""
+                    {
+                        "version": "3.0.0",
+                        "resources": [
+                            {
+                                "@id": "{{baseUrl}}/download",
+                                "@type": "PackageBaseAddress/3.0.0"
+                            },
+                            {
+                                "@id": "{{baseUrl}}/query",
+                                "@type": "SearchQueryService"
+                            },
+                            {
+                                "@id": "{{baseUrl}}/registrations",
+                                "@type": "RegistrationsBaseUrl"
+                            }
+                        ]
+                    }
+                    """),
+                // all other requests are unauthorized
+                _ => (429, "{}"),
+            };
+        }
+        // override various nuget locations
+        using var tempDir = new TemporaryDirectory();
+        using var _ = new TemporaryEnvironment(
+        [
+            ("NUGET_PACKAGES", Path.Combine(tempDir.DirectoryPath, "NUGET_PACKAGES")),
+            ("NUGET_HTTP_CACHE_PATH", Path.Combine(tempDir.DirectoryPath, "NUGET_HTTP_CACHE_PATH")),
+            ("NUGET_SCRATCH", Path.Combine(tempDir.DirectoryPath, "NUGET_SCRATCH")),
+            ("NUGET_PLUGINS_CACHE_PATH", Path.Combine(tempDir.DirectoryPath, "NUGET_PLUGINS_CACHE_PATH")),
+        ]);
+        using var http = TestHttpServer.CreateTestStringServer(TestHttpHandler);
+        var experimentsManager = new ExperimentsManager() { UseDirectDiscovery = true };
+        await TestDiscoveryAsync(
+            experimentsManager: experimentsManager,
+            workspacePath: "",
+            files:
+            [
+                ("project.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Some.Package" Version="1.2.3" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+                ("NuGet.Config", $"""
+                    <configuration>
+                      <packageSources>
+                        <clear />
+                        <add key="private_feed" value="{http.BaseUrl.TrimEnd('/')}/index.json" allowInsecureConnections="true" />
+                      </packageSources>
+                    </configuration>
+                    """),
+            ],
+            expectedResult: new()
+            {
+                Error = new PrivateSourceBadResponse([$"{http.BaseUrl.TrimEnd('/')}/index.json"]),
+                Path = "",
+                Projects = [],
+            }
+        );
+    }
+
     [LinuxOnlyFact]
     public async Task DiscoverySucceedsWhenNoWindowsAppRefPackageCanBeFound()
     {

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

@@ -106,7 +106,10 @@ public class RunWorkerTests
                       </ItemGroup>
                     </Project>
                     """.SetEOL(EOL));
-                return new UpdateOperationResult();
+                return new UpdateOperationResult()
+                {
+                    UpdateOperations = [],
+                };
             }),
             expectedResult: new RunResult()
             {
@@ -314,7 +317,10 @@ public class RunWorkerTests
                       </ItemGroup>
                     </Project>
                     """.SetEOL(EOL));
-                return new UpdateOperationResult();
+                return new UpdateOperationResult()
+                {
+                    UpdateOperations = [],
+                };
             }),
             expectedResult: new RunResult()
             {
@@ -681,7 +687,10 @@ public class RunWorkerTests
                         throw new NotSupportedException();
                 }
 
-                return new UpdateOperationResult();
+                return new UpdateOperationResult()
+                {
+                    UpdateOperations = [],
+                };
             }),
             expectedResult: new RunResult()
             {
@@ -1091,7 +1100,10 @@ public class RunWorkerTests
                         throw new NotSupportedException();
                 }
 
-                return new UpdateOperationResult();
+                return new UpdateOperationResult()
+                {
+                    UpdateOperations = [],
+                };
             }),
             expectedResult: new RunResult()
             {
@@ -1553,7 +1565,10 @@ public class RunWorkerTests
                       </PropertyGroup>
                     </Project>
                     """.SetEOL(EOL));
-                return new UpdateOperationResult();
+                return new UpdateOperationResult()
+                {
+                    UpdateOperations = [],
+                };
             }),
             expectedResult: new RunResult()
             {
@@ -2316,7 +2331,10 @@ public class RunWorkerTests
                     _ => throw new NotImplementedException("unreachable")
                 };
                 await File.WriteAllTextAsync(dependencyFilePath, updatedContent);
-                return new UpdateOperationResult();
+                return new UpdateOperationResult()
+                {
+                    UpdateOperations = [],
+                };
             }),
             expectedResult: new()
             {

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

@@ -649,6 +649,14 @@ public class SerializationTests
             """
         ];
 
+        yield return
+        [
+            new PrivateSourceBadResponse(["url1", "url2"]),
+            """
+            {"data":{"error-type":"private_source_bad_response","error-details":{"source":"(url1|url2)"}}}
+            """
+        ];
+
         yield return
         [
             new PullRequestExistsForLatestVersion("dep", "ver"),

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

@@ -0,0 +1,177 @@
+using System.Collections.Immutable;
+
+using NuGet.Versioning;
+
+using NuGetUpdater.Core.Test.Utilities;
+using NuGetUpdater.Core.Updater;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Update;
+
+public class PackageReferenceUpdaterTests
+{
+    [Theory]
+    [MemberData(nameof(ComputeUpdateOperationsTestData))]
+    public async Task ComputeUpdateOperations
+    (
+        ImmutableArray<Dependency> topLevelDependencies,
+        ImmutableArray<Dependency> requestedUpdates,
+        ImmutableArray<Dependency> resolvedDependencies,
+        ImmutableArray<UpdateOperationBase> expectedUpdateOperations
+    )
+    {
+        // arrange
+        using var repoRoot = await TemporaryDirectory.CreateWithContentsAsync(("project.csproj", "<Project Sdk=\"Microsoft.NET.Sdk\" />"));
+        var projectPath = Path.Combine(repoRoot.DirectoryPath, "project.csproj");
+        var experimentsManager = new ExperimentsManager() { UseDirectDiscovery = true };
+        await UpdateWorkerTestBase.MockNuGetPackagesInDirectory([
+            MockNuGetPackage.CreateSimplePackage("Parent.Package", "1.0.0", "net9.0", [(null, [("Transitive.Package", "1.0.0")])]),
+            MockNuGetPackage.CreateSimplePackage("Parent.Package", "2.0.0", "net9.0", [(null, [("Transitive.Package", "2.0.0")])]),
+            MockNuGetPackage.CreateSimplePackage("Transitive.Package", "1.0.0", "net9.0", [(null, [("Super.Transitive.Package", "1.0.0")])]),
+            MockNuGetPackage.CreateSimplePackage("Transitive.Package", "2.0.0", "net9.0", [(null, [("Super.Transitive.Package", "2.0.0")])]),
+            MockNuGetPackage.CreateSimplePackage("Super.Transitive.Package", "1.0.0", "net9.0"),
+            MockNuGetPackage.CreateSimplePackage("Super.Transitive.Package", "2.0.0", "net9.0")
+        ], repoRoot.DirectoryPath);
+
+        // act
+        var actualUpdateOperations = await PackageReferenceUpdater.ComputeUpdateOperations(
+            repoRoot.DirectoryPath,
+            projectPath,
+            "net9.0",
+            topLevelDependencies,
+            requestedUpdates,
+            resolvedDependencies,
+            experimentsManager,
+            new TestLogger());
+
+        // assert
+        AssertEx.Equal(expectedUpdateOperations, actualUpdateOperations);
+    }
+
+    public static IEnumerable<object[]> ComputeUpdateOperationsTestData()
+    {
+        // single dependency update
+        yield return
+        [
+            // topLevelDependencies
+            ImmutableArray.Create(
+                new Dependency("Some.Package", "1.0.0", DependencyType.PackageReference),
+                new Dependency("Unrelated.Package", "2.0.0", DependencyType.PackageReference)
+            ),
+
+            // requestedUpdates
+            ImmutableArray.Create(
+                new Dependency("Some.Package", "1.0.1", DependencyType.PackageReference)
+            ),
+
+            // resolvedDependencies
+            ImmutableArray.Create(
+                new Dependency("Some.Package", "1.0.1", DependencyType.PackageReference),
+                new Dependency("Unrelated.Package", "2.0.0", DependencyType.PackageReference)
+            ),
+
+            // expectedUpdateOperations
+            ImmutableArray.Create<UpdateOperationBase>(
+                new DirectUpdate()
+                {
+                    DependencyName = "Some.Package",
+                    NewVersion = NuGetVersion.Parse("1.0.1"),
+                    UpdatedFiles = [],
+                }
+            )
+        ];
+
+        // dependency was updated by pinning
+        yield return
+        [
+            // topLevelDependencies
+            ImmutableArray.Create(
+                new Dependency("Top.Level.Package", "1.0.0", DependencyType.PackageReference)
+            ),
+
+            // requestedUpdates
+            ImmutableArray.Create(
+                new Dependency("Transitive.Package", "2.0.0", DependencyType.PackageReference)
+            ),
+
+            // resolvedDependencies
+            ImmutableArray.Create(
+                new Dependency("Top.Level.Package", "1.0.0", DependencyType.PackageReference),
+                new Dependency("Transitive.Package", "2.0.0", DependencyType.PackageReference)
+            ),
+
+            // expectedUpdateOperations
+            ImmutableArray.Create<UpdateOperationBase>(
+                new PinnedUpdate()
+                {
+                    DependencyName = "Transitive.Package",
+                    NewVersion = NuGetVersion.Parse("2.0.0"),
+                    UpdatedFiles = [],
+                }
+            )
+        ];
+
+        // dependency was updated by updating parent 1 level up
+        yield return
+        [
+            // topLevelDependencies
+            ImmutableArray.Create(
+                new Dependency("Parent.Package", "1.0.0", DependencyType.PackageReference)
+            ),
+
+            // requestedUpdates
+            ImmutableArray.Create(
+                new Dependency("Transitive.Package", "2.0.0", DependencyType.PackageReference)
+            ),
+
+            // resolvedDependencies
+            ImmutableArray.Create(
+                new Dependency("Parent.Package", "2.0.0", DependencyType.PackageReference)
+            ),
+
+            // expectedUpdateOperations
+            ImmutableArray.Create<UpdateOperationBase>(
+                new ParentUpdate()
+                {
+                    DependencyName = "Transitive.Package",
+                    NewVersion = NuGetVersion.Parse("2.0.0"),
+                    UpdatedFiles = [],
+                    ParentDependencyName = "Parent.Package",
+                    ParentNewVersion = NuGetVersion.Parse("2.0.0"),
+                }
+            )
+        ];
+
+        // dependency was updated by updating parent 2 levels up
+        yield return
+        [
+            // topLevelDependencies
+            ImmutableArray.Create(
+                new Dependency("Parent.Package", "1.0.0", DependencyType.PackageReference)
+            ),
+
+            // requestedUpdates
+            ImmutableArray.Create(
+                new Dependency("Super.Transitive.Package", "2.0.0", DependencyType.PackageReference)
+            ),
+
+            // resolvedDependencies
+            ImmutableArray.Create(
+                new Dependency("Parent.Package", "2.0.0", DependencyType.PackageReference)
+            ),
+
+            // expectedUpdateOperations
+            ImmutableArray.Create<UpdateOperationBase>(
+                new ParentUpdate()
+                {
+                    DependencyName = "Super.Transitive.Package",
+                    NewVersion = NuGetVersion.Parse("2.0.0"),
+                    UpdatedFiles = [],
+                    ParentDependencyName = "Parent.Package",
+                    ParentNewVersion = NuGetVersion.Parse("2.0.0"),
+                }
+            )
+        ];
+    }
+}

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

@@ -0,0 +1,130 @@
+using NuGet.Versioning;
+
+using NuGetUpdater.Core.Test.Utilities;
+using NuGetUpdater.Core.Updater;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Update;
+
+public class UpdateOperationBaseTests
+{
+    [Fact]
+    public void GetReport()
+    {
+        // arrange
+        var updateOperations = new UpdateOperationBase[]
+        {
+            new DirectUpdate()
+            {
+                DependencyName = "Package.A",
+                NewVersion = NuGetVersion.Parse("1.0.0"),
+                UpdatedFiles = ["file/a.txt"]
+            },
+            new PinnedUpdate()
+            {
+                DependencyName = "Package.B",
+                NewVersion = NuGetVersion.Parse("2.0.0"),
+                UpdatedFiles = ["file/b.txt"]
+            },
+            new ParentUpdate()
+            {
+                DependencyName = "Package.C",
+                NewVersion = NuGetVersion.Parse("3.0.0"),
+                UpdatedFiles = ["file/c.txt"],
+                ParentDependencyName = "Package.D",
+                ParentNewVersion = NuGetVersion.Parse("4.0.0"),
+            },
+        };
+
+        // act
+        var actualReport = UpdateOperationBase.GenerateUpdateOperationReport(updateOperations);
+
+        // assert
+        var expectedReport = """
+            Performed the following updates:
+                - Updated Package.A to 1.0.0 in file/a.txt
+                - Pinned Package.B at 2.0.0 in file/b.txt
+                - Updated Package.C to 3.0.0 indirectly via Package.D/4.0.0 in file/c.txt
+            """.Replace("\r", "");
+        Assert.Equal(expectedReport, actualReport);
+    }
+
+    [Fact]
+    public void NormalizeUpdateOperationCollection_SortAndDistinct()
+    {
+        // arrange
+        var repoRootPath = "/repo/root";
+        var updateOperations = new UpdateOperationBase[]
+        {
+            new DirectUpdate()
+            {
+                DependencyName = "Dependency.Direct",
+                NewVersion = NuGetVersion.Parse("1.0.0"),
+                UpdatedFiles = ["/repo/root/file/a.txt"]
+            },
+            new PinnedUpdate()
+            {
+                DependencyName = "Dependency.Pinned",
+                NewVersion = NuGetVersion.Parse("2.0.0"),
+                UpdatedFiles = ["/repo/root/file/b.txt"]
+            },
+            // this is the same as the first item and will be removed
+            new DirectUpdate()
+            {
+                DependencyName = "Dependency.Direct",
+                NewVersion = NuGetVersion.Parse("1.0.0"),
+                UpdatedFiles = ["/repo/root/file/a.txt"]
+            },
+            new ParentUpdate()
+            {
+                DependencyName = "Dependency.Parent",
+                NewVersion = NuGetVersion.Parse("3.0.0"),
+                UpdatedFiles = ["/repo/root/file/c.txt"],
+                ParentDependencyName = "Dependency.Root",
+                ParentNewVersion = NuGetVersion.Parse("4.0.0"),
+            },
+        };
+
+        // act
+        var normalizedOperations = UpdateOperationBase.NormalizeUpdateOperationCollection(repoRootPath, updateOperations);
+        var normalizedDependencyNames = string.Join(", ", normalizedOperations.Select(o => o.DependencyName));
+
+        // assert
+        var expectedDependencyNames = "Dependency.Direct, Dependency.Parent, Dependency.Pinned";
+        Assert.Equal(expectedDependencyNames, normalizedDependencyNames);
+    }
+
+    [Fact]
+    public void NormalizeUpdateOperationCollection_CombinedOnTypeAndDependency()
+    {
+        // arrange
+        var repoRootPath = "/repo/root";
+        var updateOperations = new UpdateOperationBase[]
+        {
+            // both operations are the same type, same dependency, same version => files are combined
+            new DirectUpdate()
+            {
+                DependencyName = "Dependency.Direct",
+                NewVersion = NuGetVersion.Parse("1.0.0"),
+                UpdatedFiles = ["/repo/root/file/b.txt"]
+            },
+            new DirectUpdate()
+            {
+                DependencyName = "Dependency.Direct",
+                NewVersion = NuGetVersion.Parse("1.0.0"),
+                UpdatedFiles = ["/repo/root/file/a.txt"]
+            },
+        };
+
+        // act
+        var normalizedOperations = UpdateOperationBase.NormalizeUpdateOperationCollection(repoRootPath, updateOperations);
+
+        // assert
+        var singleUpdate = Assert.Single(normalizedOperations);
+        var directUpdate = Assert.IsType<DirectUpdate>(singleUpdate);
+        Assert.Equal("Dependency.Direct", directUpdate.DependencyName);
+        Assert.Equal(NuGetVersion.Parse("1.0.0"), directUpdate.NewVersion);
+        AssertEx.Equal(["/file/a.txt", "/file/b.txt"], directUpdate.UpdatedFiles);
+    }
+}

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

@@ -3,6 +3,7 @@ using System.Text.Json;
 using NuGetUpdater.Core.Run;
 using NuGetUpdater.Core.Run.ApiModel;
 using NuGetUpdater.Core.Test.Updater;
+using NuGetUpdater.Core.Test.Utilities;
 using NuGetUpdater.Core.Updater;
 
 using Xunit;
@@ -191,6 +192,10 @@ public abstract class UpdateWorkerTestBase : TestBase
         else
         {
             Assert.Null(actualResult.Error);
+            if (expectedResult is not null)
+            {
+                AssertEx.Equal(expectedResult.UpdateOperations, actualResult.UpdateOperations, UpdateOperationBaseComparer.Instance);
+            }
         }
     }
 

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

@@ -1,5 +1,7 @@
 using System.Text.Json;
 
+using NuGet.Versioning;
+
 using NuGetUpdater.Core.Run.ApiModel;
 using NuGetUpdater.Core.Updater;
 
@@ -12,16 +14,14 @@ public partial class UpdateWorkerTests
     public class Mixed : UpdateWorkerTestBase
     {
         [Fact]
-        public async Task ResultFileHasCorrectShapeForAuthenticationFailure()
+        public void ResultFileHasCorrectShapeForAuthenticationFailure()
         {
-            using var temporaryDirectory = await TemporaryDirectory.CreateWithContentsAsync([]);
             var result = new UpdateOperationResult()
             {
                 Error = new PrivateSourceAuthenticationFailure(["<some package feed>"]),
+                UpdateOperations = [],
             };
-            var resultFilePath = Path.Combine(temporaryDirectory.DirectoryPath, "update-result.json");
-            await UpdaterWorker.WriteResultFile(result, resultFilePath, new TestLogger());
-            var resultContent = await File.ReadAllTextAsync(resultFilePath);
+            var resultContent = UpdaterWorker.Serialize(result);
 
             // raw result file should look like this:
             // {
@@ -44,6 +44,72 @@ public partial class UpdateWorkerTests
             Assert.Equal("(<some package feed>)", source.GetString());
         }
 
+        [Fact]
+        public void ResultFileListsUpdateOperations()
+        {
+            var result = new UpdateOperationResult()
+            {
+                Error = null,
+                UpdateOperations = [
+                    new DirectUpdate()
+                    {
+                        DependencyName = "Package.A",
+                        NewVersion = NuGetVersion.Parse("1.0.0"),
+                        UpdatedFiles = ["a.txt"]
+                    },
+                    new PinnedUpdate()
+                    {
+                        DependencyName = "Package.B",
+                        NewVersion = NuGetVersion.Parse("2.0.0"),
+                        UpdatedFiles = ["b.txt"]
+                    },
+                    new ParentUpdate()
+                    {
+                        DependencyName = "Package.C",
+                        NewVersion = NuGetVersion.Parse("3.0.0"),
+                        UpdatedFiles = ["c.txt"],
+                        ParentDependencyName = "Package.D",
+                        ParentNewVersion = NuGetVersion.Parse("4.0.0"),
+                    }
+                ]
+            };
+            var actualJson = UpdaterWorker.Serialize(result).Replace("\r", "");
+            var expectedJson = """
+                {
+                  "UpdateOperations": [
+                    {
+                      "Type": "DirectUpdate",
+                      "DependencyName": "Package.A",
+                      "NewVersion": "1.0.0",
+                      "UpdatedFiles": [
+                        "a.txt"
+                      ]
+                    },
+                    {
+                      "Type": "PinnedUpdate",
+                      "DependencyName": "Package.B",
+                      "NewVersion": "2.0.0",
+                      "UpdatedFiles": [
+                        "b.txt"
+                      ]
+                    },
+                    {
+                      "Type": "ParentUpdate",
+                      "ParentDependencyName": "Package.D",
+                      "ParentNewVersion": "4.0.0",
+                      "DependencyName": "Package.C",
+                      "NewVersion": "3.0.0",
+                      "UpdatedFiles": [
+                        "c.txt"
+                      ]
+                    }
+                  ],
+                  "Error": null
+                }
+                """.Replace("\r", "");
+            Assert.Equal(expectedJson, actualJson);
+        }
+
         [Fact]
         public async Task ForPackagesProject_UpdatePackageReference_InBuildProps()
         {