dependabot-nuget 0.289.0 → 0.290.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Analyze/AnalyzeWorkerTestBase.cs

@@ -19,7 +19,9 @@ public class AnalyzeWorkerTestBase
         DependencyInfo dependencyInfo,
         ExpectedAnalysisResult expectedResult,
         MockNuGetPackage[]? packages = null,
-        TestFile[]? extraFiles = null)
+        TestFile[]? extraFiles = null,
+        ExperimentsManager? experimentsManager = null
+    )
     {
         var relativeDependencyPath = $"./dependabot/dependency/{dependencyInfo.Name}.json";
 
@@ -28,6 +30,7 @@ public class AnalyzeWorkerTestBase
             (relativeDependencyPath, JsonSerializer.Serialize(dependencyInfo, AnalyzeWorker.SerializerOptions)),
         ];
 
+        experimentsManager ??= new ExperimentsManager();
         var allFiles = files.Concat(extraFiles ?? []).ToArray();
         var actualResult = await RunAnalyzerAsync(dependencyInfo.Name, allFiles, async directoryPath =>
         {
@@ -36,7 +39,7 @@ public class AnalyzeWorkerTestBase
             var discoveryPath = Path.GetFullPath(DiscoveryWorker.DiscoveryResultFileName, directoryPath);
             var dependencyPath = Path.GetFullPath(relativeDependencyPath, directoryPath);
 
-            var worker = new AnalyzeWorker(new TestLogger());
+            var worker = new AnalyzeWorker(experimentsManager, new TestLogger());
             var result = await worker.RunWithErrorHandlingAsync(directoryPath, discoveryPath, dependencyPath);
             return result;
         });

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

@@ -50,6 +50,50 @@ public partial class DiscoveryWorkerTests
             );
         }
 
+        [Fact]
+        public async Task DiscoversDependenciesTrailingComma()
+        {
+            await TestDiscoveryAsync(
+                packages: [],
+                workspacePath: "",
+                files: [
+                    (".config/dotnet-tools.json", """
+                        {
+                          "version": 1,
+                          "isRoot": true,
+                          "tools": {
+                            "botsay": {
+                              "version": "1.0.0",
+                              "commands": [
+                                "botsay"
+                              ],
+                            },
+                            "dotnetsay": {
+                              "version": "1.0.0",
+                              "commands": [
+                                "dotnetsay"
+                              ],
+                            }
+                          }
+                        }
+                        """),
+                ],
+                expectedResult: new()
+                {
+                    Path = "",
+                    DotNetToolsJson = new()
+                    {
+                        FilePath = ".config/dotnet-tools.json",
+                        Dependencies = [
+                            new("botsay", "1.0.0", DependencyType.DotNetTool),
+                            new("dotnetsay", "1.0.0", DependencyType.DotNetTool),
+                        ]
+                    },
+                    ExpectedProjectCount = 0,
+                }
+            );
+        }
+
         [Fact]
         public async Task ReportsFailure()
         {
@@ -74,7 +118,7 @@ public partial class DiscoveryWorkerTests
                                 "dotnetsay"
                               ]
                             }
-                          }
+                          } INVALID JSON
                         }
                         """),
                 ],

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

@@ -40,6 +40,40 @@ public partial class DiscoveryWorkerTests
             );
         }
 
+        [Fact]
+        public async Task DiscoversDependencies_HandlesTrailingComma()
+        {
+            await TestDiscoveryAsync(
+                packages: [],
+                workspacePath: "",
+                files: [
+                    ("global.json", """
+                        {
+                          "sdk": {
+                            "version": "2.2.104"
+                          },
+                          "msbuild-sdks": {
+                            "Microsoft.Build.Traversal": "1.0.45"
+                          },
+                        }
+                        """),
+                ],
+                expectedResult: new()
+                {
+                    Path = "",
+                    GlobalJson = new()
+                    {
+                        FilePath = "global.json",
+                        Dependencies = [
+                            new("Microsoft.NET.Sdk", "2.2.104", DependencyType.MSBuildSdk),
+                            new("Microsoft.Build.Traversal", "1.0.45", DependencyType.MSBuildSdk),
+                        ]
+                    },
+                    ExpectedProjectCount = 0,
+                }
+            );
+        }
+
         [Fact]
         public async Task ReportsFailure()
         {
@@ -50,7 +84,7 @@ public partial class DiscoveryWorkerTests
                     ("global.json", """
                         {
                           "sdk": {
-                            "version": "2.2.104",
+                            "version": "2.2.104", INVALID JSON
                           },
                           "msbuild-sdks": {
                             "Microsoft.Build.Traversal": "1.0.45"

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

@@ -441,8 +441,6 @@ public partial class DiscoveryWorkerTests
                             ReferencedProjectPaths = [],
                             ImportedFiles = [
                                 "Directory.Build.targets",
-                                "NUGET_PACKAGES/microsoft.build.centralpackageversions/2.1.3/Sdk/Sdk.props", // this is an artifact of the package cache existing next to the csproj
-                                "NUGET_PACKAGES/microsoft.build.centralpackageversions/2.1.3/Sdk/Sdk.targets", // this is an artifact of the package cache existing next to the csproj
                                 "Packages.props",
                             ],
                             AdditionalFiles = [],
@@ -513,8 +511,6 @@ public partial class DiscoveryWorkerTests
                             ReferencedProjectPaths = [],
                             ImportedFiles = [
                                 "Directory.Build.targets",
-                                "NUGET_PACKAGES/microsoft.build.centralpackageversions/2.1.3/Sdk/Sdk.props", // this is an artifact of the package cache existing next to the csproj
-                                "NUGET_PACKAGES/microsoft.build.centralpackageversions/2.1.3/Sdk/Sdk.targets", // this is an artifact of the package cache existing next to the csproj
                                 "Packages.props",
                             ],
                             AdditionalFiles = [],

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

@@ -0,0 +1,85 @@
+using NuGet.Versioning;
+
+using NuGetUpdater.Core.Analyze;
+using NuGetUpdater.Core.Run;
+using NuGetUpdater.Core.Run.ApiModel;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Run;
+
+public class MiscellaneousTests
+{
+    [Theory]
+    [MemberData(nameof(RequirementsFromIgnoredVersionsData))]
+    public void RequirementsFromIgnoredVersions(string dependencyName, Condition[] ignoreConditions, Requirement[] expectedRequirements)
+    {
+        var job = new Job()
+        {
+            Source = new()
+            {
+                Provider = "github",
+                Repo = "some/repo"
+            },
+            IgnoreConditions = ignoreConditions
+        };
+        var actualRequirements = RunWorker.GetIgnoredRequirementsForDependency(job, dependencyName);
+        var actualRequirementsStrings = string.Join("|", actualRequirements.Select(r => r.ToString()));
+        var expectedRequirementsStrings = string.Join("|", expectedRequirements.Select(r => r.ToString()));
+        Assert.Equal(expectedRequirementsStrings, actualRequirementsStrings);
+    }
+
+    public static IEnumerable<object?[]> RequirementsFromIgnoredVersionsData()
+    {
+        yield return
+        [
+            // dependencyName
+            "Some.Package",
+            // ignoredConditions
+            new Condition[]
+            {
+                new()
+                {
+                    DependencyName = "SOME.PACKAGE",
+                    VersionRequirement = Requirement.Parse("> 1.2.3")
+                },
+                new()
+                {
+                    DependencyName = "some.package",
+                    VersionRequirement = Requirement.Parse("<= 2.0.0")
+                },
+                new()
+                {
+                    DependencyName = "Unrelated.Package",
+                    VersionRequirement = Requirement.Parse("= 3.4.5")
+                }
+            },
+            // expectedRequirements
+            new Requirement[]
+            {
+                new IndividualRequirement(">", NuGetVersion.Parse("1.2.3")),
+                new IndividualRequirement("<=", NuGetVersion.Parse("2.0.0")),
+            }
+        ];
+
+        // version requirement is null => ignore all
+        yield return
+        [
+            // dependencyName
+            "Some.Package",
+            // ignoredConditions
+            new Condition[]
+            {
+                new()
+                {
+                    DependencyName = "Some.Package"
+                }
+            },
+            // expectedRequirements
+            new Requirement[]
+            {
+                new IndividualRequirement(">", NuGetVersion.Parse("0.0.0"))
+            }
+        ];
+    }
+}

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

@@ -30,11 +30,7 @@ public class RunWorkerTests
                     Provider = "github",
                     Repo = "test/repo",
                     Directory = "some-dir",
-                },
-                AllowedUpdates =
-                [
-                    new() { UpdateType = "all" }
-                ]
+                }
             },
             files:
             [
@@ -237,11 +233,7 @@ public class RunWorkerTests
                     Provider = "github",
                     Repo = "test/repo",
                     Directory = "some-dir",
-                },
-                AllowedUpdates =
-                [
-                    new() { UpdateType = "all" }
-                ]
+                }
             },
             files:
             [
@@ -483,11 +475,7 @@ public class RunWorkerTests
                     Provider = "github",
                     Repo = "test/repo",
                     Directory = "/",
-                },
-                AllowedUpdates =
-                [
-                    new() { UpdateType = "all" }
-                ]
+                }
             },
             files:
             [
@@ -550,11 +538,7 @@ public class RunWorkerTests
                     Provider = "github",
                     Repo = "test/repo",
                     Directory = "some-dir",
-                },
-                AllowedUpdates =
-                [
-                    new() { UpdateType = "all" }
-                ]
+                }
             },
             files:
             [
@@ -886,11 +870,7 @@ public class RunWorkerTests
                     Provider = "github",
                     Repo = "test/repo",
                     Directory = "some-dir/ProjectA",
-                },
-                AllowedUpdates =
-                [
-                    new() { UpdateType = "all" }
-                ]
+                }
             },
             files:
             [
@@ -1438,11 +1418,7 @@ public class RunWorkerTests
                     Provider = "github",
                     Repo = "test/repo",
                     Directory = "/",
-                },
-                AllowedUpdates =
-                [
-                    new() { UpdateType = "all" }
-                ]
+                }
             },
             packages:
             [
@@ -1754,7 +1730,7 @@ public class RunWorkerTests
         var testApiHandler = new TestApiHandler();
         var logger = new TestLogger();
         discoveryWorker ??= new DiscoveryWorker(experimentsManager, logger);
-        analyzeWorker ??= new AnalyzeWorker(logger);
+        analyzeWorker ??= new AnalyzeWorker(experimentsManager, logger);
         updaterWorker ??= new UpdaterWorker(experimentsManager, logger);
 
         var worker = new RunWorker(testApiHandler, discoveryWorker, analyzeWorker, updaterWorker, logger);

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

@@ -1,5 +1,9 @@
+using NuGet.Versioning;
+
+using NuGetUpdater.Core.Analyze;
 using NuGetUpdater.Core.Run;
 using NuGetUpdater.Core.Run.ApiModel;
+using NuGetUpdater.Core.Test.Utilities;
 
 using Xunit;
 
@@ -257,6 +261,342 @@ public class SerializationTests
         Assert.Equal(expected, actual);
     }
 
+    [Fact]
+    public void DeserializeJobIgnoreConditions()
+    {
+        var jobContent = """
+            {
+              "job": {
+                "package-manager": "nuget",
+                "source": {
+                  "provider": "github",
+                  "repo": "some-org/some-repo",
+                  "directory": "specific-sdk"
+                },
+                "ignore-conditions": [
+                  {
+                    "dependency-name": "Package.1",
+                    "source": "some-file",
+                    "update-types": [
+                      "version-update:semver-major"
+                    ],
+                    "version-requirement": "> 1.2.3"
+                  },
+                  {
+                    "dependency-name": "Package.2",
+                    "updated-at": "2024-12-05T15:47:12Z"
+                  }
+                ]
+              }
+            }
+            """;
+        var jobWrapper = RunWorker.Deserialize(jobContent)!;
+        Assert.Equal(2, jobWrapper.Job.IgnoreConditions.Length);
+
+        Assert.Equal("Package.1", jobWrapper.Job.IgnoreConditions[0].DependencyName);
+        Assert.Equal("some-file", jobWrapper.Job.IgnoreConditions[0].Source);
+        Assert.Equal("version-update:semver-major", jobWrapper.Job.IgnoreConditions[0].UpdateTypes.Single());
+        Assert.Null(jobWrapper.Job.IgnoreConditions[0].UpdatedAt);
+        Assert.Equal("> 1.2.3", jobWrapper.Job.IgnoreConditions[0].VersionRequirement?.ToString());
+
+        Assert.Equal("Package.2", jobWrapper.Job.IgnoreConditions[1].DependencyName);
+        Assert.Null(jobWrapper.Job.IgnoreConditions[1].Source);
+        Assert.Empty(jobWrapper.Job.IgnoreConditions[1].UpdateTypes);
+        Assert.Equal(new DateTime(2024, 12, 5, 15, 47, 12), jobWrapper.Job.IgnoreConditions[1].UpdatedAt);
+        Assert.Null(jobWrapper.Job.IgnoreConditions[1].VersionRequirement);
+    }
+
+    [Theory]
+    [MemberData(nameof(DeserializeAllowedUpdatesData))]
+    public void DeserializeAllowedUpdates(string? allowedUpdatesJsonBody, AllowedUpdate[] expectedAllowedUpdates)
+    {
+        string? allowedUpdatesJson = allowedUpdatesJsonBody is null
+            ? null
+            : $$"""
+                ,
+                "allowed-updates": {{allowedUpdatesJsonBody}}
+                """;
+        var jobWrapperJson = $$"""
+            {
+                "job": {
+                    "source": {
+                        "provider": "github",
+                        "repo": "some/repo"
+                    }
+                    {{allowedUpdatesJson}}
+                }
+            }
+            """;
+        var jobWrapper = RunWorker.Deserialize(jobWrapperJson)!;
+        AssertEx.Equal(expectedAllowedUpdates, jobWrapper.Job.AllowedUpdates);
+    }
+
+    [Fact]
+    public void DeserializeDependencyGroups()
+    {
+        var jsonWrapperJson = """
+            {
+                "job": {
+                    "source": {
+                        "provider": "github",
+                        "repo": "some/repo"
+                    },
+                    "dependency-groups": [
+                        {
+                            "name": "Some.Dependency",
+                            "rules": {
+                                "patterns": ["1.2.3", "4.5.6"]
+                            }
+                        },
+                        {
+                            "name": "Some.Other.Dependency",
+                            "applies-to": "something"
+                        }
+                    ]
+                }
+            }
+            """;
+        var jobWrapper = RunWorker.Deserialize(jsonWrapperJson)!;
+        Assert.Equal(2, jobWrapper.Job.DependencyGroups.Length);
+
+        Assert.Equal("Some.Dependency", jobWrapper.Job.DependencyGroups[0].Name);
+        Assert.Null(jobWrapper.Job.DependencyGroups[0].AppliesTo);
+        Assert.Single(jobWrapper.Job.DependencyGroups[0].Rules);
+        Assert.Equal("[\"1.2.3\", \"4.5.6\"]", jobWrapper.Job.DependencyGroups[0].Rules["patterns"].ToString());
+
+        Assert.Equal("Some.Other.Dependency", jobWrapper.Job.DependencyGroups[1].Name);
+        Assert.Equal("something", jobWrapper.Job.DependencyGroups[1].AppliesTo);
+        Assert.Empty(jobWrapper.Job.DependencyGroups[1].Rules);
+    }
+
+    [Fact]
+    public void DeserializeExistingPullRequests()
+    {
+        var jsonWrapperJson = """
+            {
+                "job": {
+                    "source": {
+                        "provider": "github",
+                        "repo": "some/repo"
+                    },
+                    "existing-pull-requests": [
+                        [
+                            {
+                                "dependency-name": "Some.Package",
+                                "dependency-version": "1.2.3"
+                            }
+                        ]
+                    ]
+                }
+            }
+            """;
+        var jobWrapper = RunWorker.Deserialize(jsonWrapperJson)!;
+        Assert.Single(jobWrapper.Job.ExistingPullRequests);
+        Assert.Single(jobWrapper.Job.ExistingPullRequests[0]);
+        Assert.Equal("Some.Package", jobWrapper.Job.ExistingPullRequests[0][0].DependencyName);
+        Assert.Equal(NuGetVersion.Parse("1.2.3"), jobWrapper.Job.ExistingPullRequests[0][0].DependencyVersion);
+        Assert.False(jobWrapper.Job.ExistingPullRequests[0][0].DependencyRemoved);
+        Assert.Null(jobWrapper.Job.ExistingPullRequests[0][0].Directory);
+    }
+
+    [Fact]
+    public void DeserializeExistingGroupPullRequests()
+    {
+        var jsonWrapperJson = """
+            {
+                "job": {
+                    "source": {
+                        "provider": "github",
+                        "repo": "some/repo"
+                    },
+                    "existing-group-pull-requests": [
+                        {
+                            "dependency-group-name": "Some-Group-Name",
+                            "dependencies": [
+                                {
+                                    "dependency-name": "Some.Package",
+                                    "dependency-version": "1.2.3"
+                                },
+                                {
+                                    "dependency-name": "Some.Other.Package",
+                                    "dependency-version": "4.5.6",
+                                    "directory": "/some-dir"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            }
+            """;
+        var jobWrapper = RunWorker.Deserialize(jsonWrapperJson)!;
+        Assert.Single(jobWrapper.Job.ExistingGroupPullRequests);
+        Assert.Equal("Some-Group-Name", jobWrapper.Job.ExistingGroupPullRequests[0].DependencyGroupName);
+        Assert.Equal(2, jobWrapper.Job.ExistingGroupPullRequests[0].Dependencies.Length);
+        Assert.Equal("Some.Package", jobWrapper.Job.ExistingGroupPullRequests[0].Dependencies[0].DependencyName);
+        Assert.Equal("1.2.3", jobWrapper.Job.ExistingGroupPullRequests[0].Dependencies[0].DependencyVersion.ToString());
+        Assert.Null(jobWrapper.Job.ExistingGroupPullRequests[0].Dependencies[0].Directory);
+        Assert.Equal("Some.Other.Package", jobWrapper.Job.ExistingGroupPullRequests[0].Dependencies[1].DependencyName);
+        Assert.Equal("4.5.6", jobWrapper.Job.ExistingGroupPullRequests[0].Dependencies[1].DependencyVersion.ToString());
+        Assert.Equal("/some-dir", jobWrapper.Job.ExistingGroupPullRequests[0].Dependencies[1].Directory);
+    }
+
+    [Theory]
+    [InlineData("null", null)]
+    [InlineData("\"bump_versions\"", RequirementsUpdateStrategy.BumpVersions)]
+    [InlineData("\"lockfile_only\"", RequirementsUpdateStrategy.LockfileOnly)]
+    public void DeserializeRequirementsUpdateStrategy(string requirementsUpdateStrategyStringJson, RequirementsUpdateStrategy? expectedRequirementsUpdateStrategy)
+    {
+        var jsonWrapperJson = $$"""
+            {
+                "job": {
+                    "source": {
+                        "provider": "github",
+                        "repo": "some/repo"
+                    },
+                    "requirements-update-strategy": {{requirementsUpdateStrategyStringJson}}
+                }
+            }
+            """;
+        var jobWrapper = RunWorker.Deserialize(jsonWrapperJson)!;
+        var actualRequirementsUpdateStrategy = jobWrapper.Job.RequirementsUpdateStrategy;
+        Assert.Equal(expectedRequirementsUpdateStrategy, actualRequirementsUpdateStrategy);
+    }
+
+    [Fact]
+    public void DeserializeSecurityAdvisories()
+    {
+        var jsonWrapperJson = """
+            {
+                "job": {
+                    "source": {
+                        "provider": "github",
+                        "repo": "some/repo"
+                    },
+                    "security-advisories": [
+                        {
+                            "dependency-name": "Some.Package",
+                            "affected-versions": [
+                                ">= 1.0.0, < 1.2.0"
+                            ],
+                            "patched-versions": null
+                        }
+                    ]
+                }
+            }
+            """;
+        var jobWrapper = RunWorker.Deserialize(jsonWrapperJson)!;
+        Assert.Single(jobWrapper.Job.SecurityAdvisories);
+        Assert.Equal("Some.Package", jobWrapper.Job.SecurityAdvisories[0].DependencyName);
+        Assert.Equal(">= 1.0.0, < 1.2.0", jobWrapper.Job.SecurityAdvisories[0].AffectedVersions!.Value.Single().ToString());
+        Assert.Null(jobWrapper.Job.SecurityAdvisories[0].PatchedVersions);
+        Assert.Null(jobWrapper.Job.SecurityAdvisories[0].PatchedVersions);
+    }
+
+    [Fact]
+    public void DeserializeCommitOptions()
+    {
+        var jsonWrapperJson = """
+            {
+                "job": {
+                    "source": {
+                        "provider": "github",
+                        "repo": "some/repo"
+                    },
+                    "commit-message-options": {
+                        "prefix": "[SECURITY] "
+                    }
+                }
+            }
+            """;
+        var jobWrapper = RunWorker.Deserialize(jsonWrapperJson)!;
+        Assert.Equal("[SECURITY] ", jobWrapper.Job.CommitMessageOptions!.Prefix);
+        Assert.Null(jobWrapper.Job.CommitMessageOptions!.PrefixDevelopment);
+        Assert.Null(jobWrapper.Job.CommitMessageOptions!.IncludeScope);
+    }
+
+    public static IEnumerable<object?[]> DeserializeAllowedUpdatesData()
+    {
+        // common default value - most job files look like this
+        yield return
+        [
+            // allowedUpdatesJsonBody
+            """
+            [
+                {
+                    "update-type": "all"
+                }
+            ]
+            """,
+            // expectedAllowedUpdates
+            new[]
+            {
+                new AllowedUpdate()
+                {
+                    DependencyType = Core.Run.ApiModel.DependencyType.All,
+                    DependencyName = null,
+                    UpdateType = UpdateType.All
+                }
+            }
+        ];
+
+        // allowed updates is missing - ensure proper defaults
+        yield return
+        [
+            // allowedUpdatesJsonBody
+            null,
+            // expectedAllowedUpdates
+            new[]
+            {
+                new AllowedUpdate()
+            }
+        ];
+
+        // multiple non-default values
+        yield return
+        [
+            // allowedUpdatesJsonBody
+            """
+            [
+                {
+                    "dependency-type": "indirect",
+                    "dependency-name": "Dependency.One",
+                    "update-type": "security"
+                },
+                {
+                    "dependency-type": "production",
+                    "dependency-name": "Dependency.Two",
+                    "update-type": "all"
+                },
+                {
+                    "dependency-type": "indirect",
+                    "update-type": "security"
+                }
+            ]
+            """,
+            new[]
+            {
+                new AllowedUpdate()
+                {
+                    DependencyType = Core.Run.ApiModel.DependencyType.Indirect,
+                    DependencyName = "Dependency.One",
+                    UpdateType = UpdateType.Security
+                },
+                new AllowedUpdate()
+                {
+                    DependencyType = Core.Run.ApiModel.DependencyType.Production,
+                    DependencyName = "Dependency.Two",
+                    UpdateType = UpdateType.All
+                },
+                new AllowedUpdate()
+                {
+                    DependencyType = Core.Run.ApiModel.DependencyType.Indirect,
+                    DependencyName = null,
+                    UpdateType = UpdateType.Security
+                }
+            }
+        ];
+    }
+
     private class CapturingTestLogger : ILogger
     {
         private readonly List<string> _messages = new();