dependabot-nuget 0.315.0 → 0.316.0

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

@@ -82,6 +82,7 @@ public class MessageReportTests
                 CommitMessage = "unused",
                 PrTitle = "unused",
                 PrBody = "unused",
+                DependencyGroup = null, // unused
             },
             // expected
             """
@@ -171,6 +172,53 @@ public class MessageReportTests
             """
         ];
 
+        yield return
+        [
+            // message
+            new PullRequestExistsForSecurityUpdate([new("Some.Dependency", "1.2.3", DependencyType.PackageReference)]),
+            // expected
+            """
+            Error type: pull_request_exists_for_security_update
+            - updated-dependencies:
+              - - dependency-name: Some.Dependency
+                - dependency-version: 1.2.3
+                - dependency-removed: false
+            """
+        ];
+
+        yield return
+        [
+            // message
+            new SecurityUpdateDependencyNotFound(),
+            // expected
+            """
+            Error type: security_update_dependency_not_found
+            """
+        ];
+
+        yield return
+        [
+            // message
+            new SecurityUpdateIgnored("Some.Dependency"),
+            // expected
+            """
+            Error type: all_versions_ignored
+            - dependency-name: Some.Dependency
+            """
+        ];
+
+        yield return
+        [
+            // message
+            new SecurityUpdateNotFound("Some.Dependency", "1.2.3"),
+            // expected
+            """
+            Error type: security_update_not_found
+            - dependency-name: Some.Dependency
+            - dependency-version: 1.2.3
+            """
+        ];
+
         yield return
         [
             // message
@@ -182,6 +230,22 @@ public class MessageReportTests
             """
         ];
 
+        yield return
+        [
+            // message
+            new SecurityUpdateNotPossible("Some.Dependency", "1.2.3", "4.5.6", ["dep1", "dep2"]),
+            // expected
+            """
+            Error type: security_update_not_possible
+            - dependency-name: Some.Dependency
+            - latest-resolvable-version: 1.2.3
+            - lowest-non-vulnerable-version: 4.5.6
+            - conflicting-dependencies:
+              - dep1
+              - dep2
+            """
+        ];
+
         yield return
         [
             // message
@@ -203,7 +267,9 @@ public class MessageReportTests
             // expected
             """
             Error type: update_not_possible
-            - dependencies: Dependency1, Dependency2
+            - dependencies:
+              - Dependency1
+              - Dependency2
             """
         ];
 

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

@@ -7,6 +7,7 @@ using NuGetUpdater.Core.Analyze;
 using NuGetUpdater.Core.Discover;
 using NuGetUpdater.Core.Run;
 using NuGetUpdater.Core.Run.ApiModel;
+using NuGetUpdater.Core.Test.Utilities;
 
 using Xunit;
 
@@ -14,6 +15,450 @@ namespace NuGetUpdater.Core.Test.Run;
 
 public class MiscellaneousTests
 {
+    [Theory]
+    [MemberData(nameof(IsDependencyIgnoredTestData))]
+    public void IsDependencyIgnored(Condition[] ignoreConditions, string dependencyName, string dependencyVersion, bool expectedIgnored)
+    {
+        // arrange
+        var job = new Job()
+        {
+            Source = new()
+            {
+                Provider = "github",
+                Repo = "some/repo"
+            },
+            IgnoreConditions = ignoreConditions,
+        };
+
+        // act
+        var actualIsIgnored = job.IsDependencyIgnored(dependencyName, dependencyVersion);
+
+        // assert
+        Assert.Equal(expectedIgnored, actualIsIgnored);
+    }
+
+    public static IEnumerable<object[]> IsDependencyIgnoredTestData()
+    {
+        yield return
+        [
+            // ignoreConditions
+            new[]
+            {
+                new Condition()
+                {
+                    DependencyName = "Different.Dependency",
+                }
+            },
+            // dependencyName
+            "Some.Dependency",
+            // dependencyVersion
+            "1.2.3",
+            // expectedIgnored
+            false,
+        ];
+
+        yield return
+        [
+            // ignoreConditions
+            new[]
+            {
+                new Condition()
+                {
+                    DependencyName = "Some.Dependency",
+                    VersionRequirement = Requirement.Parse("> 2.0.0"),
+                }
+            },
+            // dependencyName
+            "Some.Dependency",
+            // dependencyVersion
+            "1.2.3",
+            // expectedIgnored
+            false,
+        ];
+
+        yield return
+        [
+            // ignoreConditions
+            new[]
+            {
+                new Condition()
+                {
+                    DependencyName = "Some.Dependency",
+                    VersionRequirement = Requirement.Parse("> 1.0.0"),
+                }
+            },
+            // dependencyName
+            "Some.Dependency",
+            // dependencyVersion
+            "1.2.3",
+            // expectedIgnored
+            true,
+        ];
+
+        yield return
+        [
+            // ignoreConditions
+            new[]
+            {
+                new Condition()
+                {
+                    DependencyName = "Some.*",
+                }
+            },
+            // dependencyName
+            "Some.Dependency",
+            // dependencyVersion
+            "1.2.3",
+            // expectedIgnored
+            true,
+        ];
+    }
+
+    [Theory]
+    [MemberData(nameof(DependencyGroup_IsMatchTestData))]
+    public void DependencyGroup_IsMatch(string[]? patterns, string[]? excludePatterns, string dependencyName, bool expectedMatch)
+    {
+        var rules = new Dictionary<string, object>();
+        if (patterns is not null)
+        {
+            rules["patterns"] = patterns;
+        }
+
+        if (excludePatterns is not null)
+        {
+            rules["exclude-patterns"] = excludePatterns;
+        }
+
+        var group = new DependencyGroup()
+        {
+            Name = "TestGroup",
+            Rules = rules,
+        };
+        var matcher = group.GetGroupMatcher();
+        var isMatch = matcher.IsMatch(dependencyName);
+        Assert.Equal(expectedMatch, isMatch);
+    }
+
+    public static IEnumerable<object?[]> DependencyGroup_IsMatchTestData()
+    {
+        yield return
+        [
+            null, // patterns
+            null, // excludePatterns
+            "Some.Package", // dependencyName
+            true, // expectMatch
+        ];
+
+        yield return
+        [
+            new[] { "*" }, // patterns
+            null, // excludePatterns
+            "Some.Package", // dependencyName
+            true, // expectMatch
+        ];
+
+        yield return
+        [
+            new[] { "some.*" }, // patterns
+            null, // excludePatterns
+            "Some.Package", // dependencyName
+            true, // expectMatch
+        ];
+
+        yield return
+        [
+            null, // patterns
+            new[] { "some.*" }, // excludePatterns
+            "Some.Package", // dependencyName
+            false, // expectMatch
+        ];
+
+        yield return
+        [
+            new[] { "*" }, // patterns
+            new[] { "some.*" }, // excludePatterns
+            "Some.Package", // dependencyName
+            false, // expectMatch
+        ];
+
+        yield return
+        [
+            new[] { "*" }, // patterns
+            new[] { "other.*" }, // excludePatterns
+            "Some.Package", // dependencyName
+            true, // expectMatch
+        ];
+    }
+
+    [Theory]
+    [MemberData(nameof(GetMatchingPullRequestTestData))]
+    public void GetMatchingPullRequest(Job job, IEnumerable<Dependency> dependencies, bool considerVersions, string? expectedGroupPrName, string[]? expectedPrDependencyNames)
+    {
+        var existingPr = job.GetExistingPullRequestForDependencies(dependencies, considerVersions);
+
+        if (expectedPrDependencyNames is null)
+        {
+            Assert.Null(existingPr);
+            return;
+        }
+        else
+        {
+            Assert.NotNull(existingPr);
+        }
+
+        Assert.Equal(expectedGroupPrName, existingPr.Item1);
+
+        var actualPrDependencyNames = existingPr.Item2
+            .Select(d => d.DependencyName)
+            .OrderBy(name => name, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+        AssertEx.Equal(expectedPrDependencyNames, actualPrDependencyNames);
+    }
+
+    public static IEnumerable<object?[]> GetMatchingPullRequestTestData()
+    {
+        var source = new JobSource()
+        {
+            Provider = "github",
+            Repo = "test/repo",
+        };
+
+        // match found, version match
+        yield return
+        [
+            // job
+            new Job()
+            {
+                Source = source,
+                ExistingPullRequests = [
+                    new()
+                    {
+                        Dependencies = [
+                            new()
+                            {
+                                DependencyName = "Dependency.A",
+                                DependencyVersion = NuGetVersion.Parse("1.0.0"),
+                            },
+                            new()
+                            {
+                                DependencyName = "Dependency.B",
+                                DependencyVersion = NuGetVersion.Parse("2.0.0"),
+                            }
+                        ]
+                    }
+                ]
+            },
+            // dependencies
+            new[]
+            {
+                new Dependency("Dependency.A", "1.0.0", DependencyType.Unknown),
+                new Dependency("Dependency.B", "2.0.0", DependencyType.Unknown),
+            },
+            // considerVersions
+            true,
+            // expectedGroupPrName
+            null,
+            // expectedPrDependencyNames
+            new[] { "Dependency.A", "Dependency.B" },
+        ];
+
+        // match found, version agnostic
+        yield return
+        [
+            // job
+            new Job()
+            {
+                Source = source,
+                ExistingPullRequests = [
+                    new()
+                    {
+                        Dependencies = [
+                            new()
+                            {
+                                DependencyName = "Dependency.A",
+                                DependencyVersion = NuGetVersion.Parse("1.0.0"),
+                            },
+                            new()
+                            {
+                                DependencyName = "Dependency.B",
+                                DependencyVersion = NuGetVersion.Parse("2.0.0"),
+                            }
+                        ]
+                    }
+                ]
+            },
+            // dependencies
+            new[]
+            {
+                new Dependency("Dependency.A", "3.0.0", DependencyType.Unknown),
+                new Dependency("Dependency.B", "4.0.0", DependencyType.Unknown),
+            },
+            // considerVersions
+            false,
+            // expectedGroupPrName
+            null,
+            // expectedPrDependencyNames
+            new[] { "Dependency.A", "Dependency.B" },
+        ];
+
+        // match not found, version didn't match
+        yield return
+        [
+            // job
+            new Job()
+            {
+                Source = source,
+                ExistingPullRequests = [
+                    new()
+                    {
+                        Dependencies = [
+                            new()
+                            {
+                                DependencyName = "Dependency.A",
+                                DependencyVersion = NuGetVersion.Parse("1.0.0"),
+                            },
+                            new()
+                            {
+                                DependencyName = "Dependency.B",
+                                DependencyVersion = NuGetVersion.Parse("2.0.0"),
+                            }
+                        ]
+                    }
+                ]
+            },
+            // dependencies
+            new[]
+            {
+                new Dependency("Dependency.A", "1.0.0", DependencyType.Unknown),
+                new Dependency("Dependency.B", "3.0.0", DependencyType.Unknown),
+            },
+            // considerVersions
+            true,
+            // expectedGroupPrName
+            null,
+            // expectedPrDependencyNames
+            null,
+        ];
+
+        // no match found, missing a dependency
+        yield return
+        [
+            // job
+            new Job()
+            {
+                Source = source,
+                ExistingPullRequests = [
+                    new()
+                    {
+                        Dependencies = [
+                            new()
+                            {
+                                DependencyName = "Dependency.A",
+                                DependencyVersion = NuGetVersion.Parse("1.0.0"),
+                            },
+                            new()
+                            {
+                                DependencyName = "Dependency.B",
+                                DependencyVersion = NuGetVersion.Parse("2.0.0"),
+                            }
+                        ]
+                    }
+                ]
+            },
+            // dependencies
+            new[]
+            {
+                new Dependency("Dependency.A", "1.0.0", DependencyType.Unknown),
+            },
+            // considerVersions
+            true,
+            // expectedGroupPrName
+            null,
+            // expectedPrDependencyNames
+            null,
+        ];
+
+        // no match found, extra dependency
+        yield return
+        [
+            // job
+            new Job()
+            {
+                Source = source,
+                ExistingPullRequests = [
+                    new()
+                    {
+                        Dependencies = [
+                            new()
+                            {
+                                DependencyName = "Dependency.A",
+                                DependencyVersion = NuGetVersion.Parse("1.0.0"),
+                            },
+                            new()
+                            {
+                                DependencyName = "Dependency.B",
+                                DependencyVersion = NuGetVersion.Parse("2.0.0"),
+                            }
+                        ]
+                    }
+                ]
+            },
+            // dependencies
+            new[]
+            {
+                new Dependency("Dependency.A", "1.0.0", DependencyType.Unknown),
+                new Dependency("Dependency.B", "2.0.0", DependencyType.Unknown),
+                new Dependency("Dependency.C", "3.0.0", DependencyType.Unknown),
+            },
+            // considerVersions
+            false,
+            // expectedGroupPrName
+            null,
+            // expectedPrDependencyNames
+            null,
+        ];
+
+        // match found with group
+        yield return
+        [
+            // job
+            new Job()
+            {
+                Source = source,
+                ExistingGroupPullRequests = [
+                    new()
+                    {
+                        DependencyGroupName = "test-group",
+                        Dependencies = [
+                            new()
+                            {
+                                DependencyName = "Dependency.A",
+                                DependencyVersion = NuGetVersion.Parse("1.0.0"),
+                            },
+                            new()
+                            {
+                                DependencyName = "Dependency.B",
+                                DependencyVersion = NuGetVersion.Parse("2.0.0"),
+                            }
+                        ]
+                    }
+                ]
+            },
+            // dependencies
+            new[]
+            {
+                new Dependency("Dependency.A", "1.0.0", DependencyType.Unknown),
+                new Dependency("Dependency.B", "2.0.0", DependencyType.Unknown),
+            },
+            // considerVersions
+            true,
+            // expectedGroupPrName
+            "test-group",
+            // expectedPrDependencyNames
+            new[] { "Dependency.A", "Dependency.B" },
+        ];
+    }
+
     [Theory]
     [MemberData(nameof(RequirementsFromIgnoredVersionsData))]
     public void RequirementsFromIgnoredVersions(string dependencyName, Condition[] ignoreConditions, Requirement[] expectedRequirements)

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

@@ -82,6 +82,7 @@ public class PullRequestMessageTests
                 CommitMessage = RunWorkerTests.TestPullRequestCommitMessage,
                 PrTitle = RunWorkerTests.TestPullRequestTitle,
                 PrBody = RunWorkerTests.TestPullRequestBody,
+                DependencyGroup = null,
             }
         ];