dependabot-nuget 0.301.1 → 0.303.0

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

@@ -0,0 +1,99 @@
+using NuGetUpdater.Core.Updater;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Update;
+
+public class SpecialFilePatcherTests
+{
+    [Theory]
+    [MemberData(nameof(SpecialImportsConditionPatcherTestData))]
+    public async Task SpecialImportsConditionPatcher(string fileContent, string expectedPatchedContent)
+    {
+        // arrange
+        var projectFileName = "project.csproj";
+        using var tempDir = await TemporaryDirectory.CreateWithContentsAsync((projectFileName, fileContent));
+        var projectPath = Path.Join(tempDir.DirectoryPath, projectFileName);
+
+        // act
+        using (var patcher = new SpecialImportsConditionPatcher(projectPath))
+        {
+            var actualPatchedContent = await File.ReadAllTextAsync(projectPath);
+
+            // assert
+            Assert.Equal(expectedPatchedContent.Replace("\r", ""), actualPatchedContent.Replace("\r", ""));
+        }
+
+        // assert again
+        var restoredContent = await File.ReadAllTextAsync(projectPath);
+        Assert.Equal(restoredContent.Replace("\r", ""), fileContent.Replace("\r", ""));
+    }
+
+    public static IEnumerable<object[]> SpecialImportsConditionPatcherTestData()
+    {
+        // one-off test to verify namespaces don't interfere
+        yield return
+        [
+            // fileContent
+            """
+            <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+              <Import Project="Unrelated.One.targets" />
+              <Import Project="Some\Path\Microsoft.WebApplication.targets" />
+              <Import Project="Unrelated.Two.targets" />
+            </Project>
+            """,
+            // expectedPatchedContent
+            """
+            <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+              <Import Project="Unrelated.One.targets" />
+              <Import Project="Some\Path\Microsoft.WebApplication.targets" Condition="false" />
+              <Import Project="Unrelated.Two.targets" />
+            </Project>
+            """
+        ];
+
+        // one-off test to verify existing conditions are restored
+        yield return
+        [
+            // fileContent
+            """
+            <Project>
+              <Import Project="Unrelated.One.targets" />
+              <Import Project="Some\Path\Microsoft.WebApplication.targets" Condition="existing condition" />
+              <Import Project="Unrelated.Two.targets" />
+            </Project>
+            """,
+            // expectedPatchedContent
+            """
+            <Project>
+              <Import Project="Unrelated.One.targets" />
+              <Import Project="Some\Path\Microsoft.WebApplication.targets" Condition="false" />
+              <Import Project="Unrelated.Two.targets" />
+            </Project>
+            """
+        ];
+
+        // all file variations - by its nature, also verifies that multiple replacements can occur
+        yield return
+        [
+            // fileContent
+            """
+            <Project>
+              <Import Project="Unrelated.One.targets" />
+              <Import Project="Some\Path\Microsoft.TextTemplating.targets" />
+              <Import Project="Some\Path\Microsoft.WebApplication.targets" />
+              <Import Project="Unrelated.Two.targets" />
+            </Project>
+            """,
+            // expectedPatchedContent
+            """
+            <Project>
+              <Import Project="Unrelated.One.targets" />
+              <Import Project="Some\Path\Microsoft.TextTemplating.targets" Condition="false" />
+              <Import Project="Some\Path\Microsoft.WebApplication.targets" Condition="false" />
+              <Import Project="Unrelated.Two.targets" />
+            </Project>
+            """
+        ];
+    }
+}

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()
         {