dependabot-nuget 0.284.0 → 0.286.0

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

@@ -59,6 +59,162 @@ public class SerializationTests
         Assert.Equal("specific-sdk", jobWrapper.Job.Source.Directory);
     }
 
+    [Fact]
+    public void DeserializeJob_FieldsNotYetSupported()
+    {
+        // the `source` field is required in the C# model; the remaining fields might exist in the JSON file, but are
+        // not yet supported in the C# model (some keys missing, others deserialize to `object?`; deserialization
+        // should not fail
+        var jobWrapper = RunWorker.Deserialize("""
+            {
+              "job": {
+                "source": {
+                  "provider": "github",
+                  "repo": "some-org/some-repo",
+                  "directory": "specific-sdk",
+                  "hostname": null,
+                  "api-endpoint": null
+                },
+                "id": "some-id",
+                "allowed-updates": [
+                  {
+                    "dependency-type": "direct",
+                    "update-type": "all"
+                  }
+                ],
+                "credentials": [
+                  {
+                    "name": "some-cred",
+                    "token": "abc123"
+                  }
+                ],
+                "existing-pull-requests": [
+                  [
+                    {
+                      "dependency-name": "Some.Package",
+                      "dependency-version": "1.2.3"
+                    }
+                  ]
+                ],
+                "repo-contents-path": "/path/to/repo",
+                "token": "abc123"
+              }
+            }
+            """);
+        Assert.Equal("github", jobWrapper.Job.Source.Provider);
+        Assert.Equal("some-org/some-repo", jobWrapper.Job.Source.Repo);
+        Assert.Equal("specific-sdk", jobWrapper.Job.Source.Directory);
+    }
+
+    [Fact]
+    public void DeserializeExperimentsManager()
+    {
+        var jobWrapper = RunWorker.Deserialize("""
+            {
+              "job": {
+                "package-manager": "nuget",
+                "allowed-updates": [
+                  {
+                    "update-type": "all"
+                  }
+                ],
+                "source": {
+                  "provider": "github",
+                  "repo": "some-org/some-repo",
+                  "directory": "some-dir"
+                },
+                "experiments": {
+                  "nuget_legacy_dependency_solver": true,
+                  "unexpected_bool": true,
+                  "unexpected_number": 42,
+                  "unexpected_null": null,
+                  "unexpected_string": "abc",
+                  "unexpected_array": [1, "two", 3.0],
+                  "unexpected_object": {
+                    "a": 1,
+                    "b": "two"
+                  }
+                }
+              }
+            }
+            """);
+        var experimentsManager = ExperimentsManager.GetExperimentsManager(jobWrapper.Job.Experiments);
+        Assert.True(experimentsManager.UseLegacyDependencySolver);
+    }
+
+    [Fact]
+    public void DeserializeExperimentsManager_EmptyExperiments()
+    {
+        var jobWrapper = RunWorker.Deserialize("""
+            {
+              "job": {
+                "package-manager": "nuget",
+                "allowed-updates": [
+                  {
+                    "update-type": "all"
+                  }
+                ],
+                "source": {
+                  "provider": "github",
+                  "repo": "some-org/some-repo",
+                  "directory": "some-dir"
+                },
+                "experiments": {
+                }
+              }
+            }
+            """);
+        var experimentsManager = ExperimentsManager.GetExperimentsManager(jobWrapper.Job.Experiments);
+        Assert.False(experimentsManager.UseLegacyDependencySolver);
+    }
+
+    [Fact]
+    public void DeserializeExperimentsManager_NoExperiments()
+    {
+        var jobWrapper = RunWorker.Deserialize("""
+            {
+              "job": {
+                "package-manager": "nuget",
+                "allowed-updates": [
+                  {
+                    "update-type": "all"
+                  }
+                ],
+                "source": {
+                  "provider": "github",
+                  "repo": "some-org/some-repo",
+                  "directory": "some-dir"
+                }
+              }
+            }
+            """);
+        var experimentsManager = ExperimentsManager.GetExperimentsManager(jobWrapper.Job.Experiments);
+        Assert.False(experimentsManager.UseLegacyDependencySolver);
+    }
+
+    [Fact]
+    public async Task DeserializeExperimentsManager_UnsupportedJobFileShape_InfoIsReportedAndEmptyExperimentSetIsReturned()
+    {
+        // arrange
+        using var tempDir = new TemporaryDirectory();
+        var jobFilePath = Path.Combine(tempDir.DirectoryPath, "job.json");
+        var jobContent = """
+            {
+              "this-is-not-a-job-and-parsing-will-fail-but-an-empty-experiment-set-should-sill-be-returned": {
+              }
+            }
+            """;
+        await File.WriteAllTextAsync(jobFilePath, jobContent);
+        var capturingTestLogger = new CapturingTestLogger();
+
+        // act - this is the entrypoint the update command uses to parse the job file
+        var experimentsManager = await ExperimentsManager.FromJobFileAsync(jobFilePath, capturingTestLogger);
+
+        // assert
+        Assert.False(experimentsManager.UseLegacyDependencySolver);
+        Assert.Single(capturingTestLogger.Messages.Where(m => m.Contains("Error deserializing job file")));
+    }
+
     [Fact]
     public void SerializeError()
     {
@@ -67,4 +223,16 @@ public class SerializationTests
         var expected = """{"data":{"error-type":"job_repo_not_found","error-details":{"message":"some message"}}}""";
         Assert.Equal(expected, actual);
     }
+
+    private class CapturingTestLogger : ILogger
+    {
+        private readonly List<string> _messages = new();
+
+        public IReadOnlyList<string> Messages => _messages;
+
+        public void Log(string message)
+        {
+            _messages.Add(message);
+        }
+    }
 }

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

@@ -13,6 +13,18 @@ public class UpdatedDependencyListTests
     [Fact]
     public void GetUpdatedDependencyListFromDiscovery()
     {
+        using var temp = new TemporaryDirectory();
+        Directory.CreateDirectory(Path.Combine(temp.DirectoryPath, "src", "a"));
+        Directory.CreateDirectory(Path.Combine(temp.DirectoryPath, "src", "b"));
+        Directory.CreateDirectory(Path.Combine(temp.DirectoryPath, "src", "c"));
+
+        File.WriteAllText(Path.Combine(temp.DirectoryPath, "src", "a", "packages.config"), "");
+        File.WriteAllText(Path.Combine(temp.DirectoryPath, "src", "b", "packages.config"), "");
+        File.WriteAllText(Path.Combine(temp.DirectoryPath, "src", "c", "packages.config"), "");
+        File.WriteAllText(Path.Combine(temp.DirectoryPath, "src", "a", "project.csproj"), "");
+        File.WriteAllText(Path.Combine(temp.DirectoryPath, "src", "b", "project.csproj"), "");
+        File.WriteAllText(Path.Combine(temp.DirectoryPath, "src", "c", "project.csproj"), "");
+
         var discovery = new WorkspaceDiscoveryResult()
         {
             Path = "src",
@@ -20,10 +32,31 @@ public class UpdatedDependencyListTests
             Projects = [
                 new()
                 {
-                    FilePath = "project.csproj",
+                    FilePath = "a/project.csproj",
                     Dependencies = [
                         new("Microsoft.Extensions.DependencyModel", "6.0.0", DependencyType.PackageReference, TargetFrameworks: ["net6.0"]),
+                    ],
+                    IsSuccess = true,
+                    Properties = [],
+                    TargetFrameworks = ["net8.0"],
+                    ReferencedProjectPaths = [],
+                },
+                new()
+                {
+                    FilePath = "b/project.csproj",
+                    Dependencies = [
+                    ],
+                    IsSuccess = true,
+                    Properties = [],
+                    TargetFrameworks = ["net8.0"],
+                    ReferencedProjectPaths = [],
+                },
+                new()
+                {
+                    FilePath = "c/project.csproj",
+                    Dependencies = [
                         new("System.Text.Json", "6.0.0", DependencyType.Unknown, TargetFrameworks: ["net6.0"], IsTransitive: true),
+                        new("Newtonsoft.Json", "13.0.1", DependencyType.PackagesConfig, TargetFrameworks: ["net6.0"]),
                     ],
                     IsSuccess = true,
                     Properties = [],
@@ -32,7 +65,7 @@ public class UpdatedDependencyListTests
                 }
             ]
         };
-        var updatedDependencyList = RunWorker.GetUpdatedDependencyListFromDiscovery(discovery);
+        var updatedDependencyList = RunWorker.GetUpdatedDependencyListFromDiscovery(discovery, pathToContents: temp.DirectoryPath);
         var expectedDependencyList = new UpdatedDependencyList()
         {
             Dependencies =
@@ -46,9 +79,9 @@ public class UpdatedDependencyListTests
                         new ReportedRequirement()
                         {
                             Requirement = "6.0.0",
-                            File = "/src/project.csproj",
+                            File = "/src/a/project.csproj",
                             Groups = ["dependencies"],
-                        }
+                        },
                     ]
                 },
                 new ReportedDependency()
@@ -56,9 +89,23 @@ public class UpdatedDependencyListTests
                     Name = "System.Text.Json",
                     Version = "6.0.0",
                     Requirements = [],
-                }
+                },
+                new ReportedDependency()
+                {
+                    Name = "Newtonsoft.Json",
+                    Version = "13.0.1",
+                    Requirements =
+                    [
+                        new ReportedRequirement()
+                        {
+                            Requirement = "13.0.1",
+                            File = "/src/c/packages.config",
+                            Groups = ["dependencies"],
+                        },
+                    ]
+                },
             ],
-            DependencyFiles = ["/src/project.csproj"],
+            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"],
         };
 
         // 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/TestAnalyzeWorker.cs

@@ -0,0 +1,37 @@
+using NuGetUpdater.Core.Analyze;
+using NuGetUpdater.Core.Discover;
+
+namespace NuGetUpdater.Core.Test;
+
+internal class TestAnalyzeWorker : IAnalyzeWorker
+{
+    private readonly Func<(string, WorkspaceDiscoveryResult, DependencyInfo), Task<AnalysisResult>> _getResult;
+
+    public TestAnalyzeWorker(Func<(string, WorkspaceDiscoveryResult, DependencyInfo), Task<AnalysisResult>> getResult)
+    {
+        _getResult = getResult;
+    }
+
+    public Task<AnalysisResult> RunAsync(string repoRoot, WorkspaceDiscoveryResult discovery, DependencyInfo dependencyInfo)
+    {
+        return _getResult((repoRoot, discovery, dependencyInfo));
+    }
+
+    public static TestAnalyzeWorker FromResults(params (string RepoRoot, WorkspaceDiscoveryResult Discovery, DependencyInfo DependencyInfo, AnalysisResult Result)[] results)
+    {
+        return new TestAnalyzeWorker(((string RepoRoot, WorkspaceDiscoveryResult Discovery, DependencyInfo DependencyInfo) input) =>
+        {
+            foreach (var set in results)
+            {
+                if (set.RepoRoot == input.RepoRoot &&
+                    set.Discovery == input.Discovery &&
+                    set.DependencyInfo == input.DependencyInfo)
+                {
+                    return Task.FromResult(set.Result);
+                }
+            }
+
+            throw new NotImplementedException($"No saved response for {input}");
+        });
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/TestDiscoveryWorker.cs

@@ -0,0 +1,35 @@
+using NuGetUpdater.Core.Discover;
+
+namespace NuGetUpdater.Core.Test;
+
+internal class TestDiscoveryWorker : IDiscoveryWorker
+{
+    private readonly Func<(string, string), Task<WorkspaceDiscoveryResult>> _getResult;
+
+    public TestDiscoveryWorker(Func<(string, string), Task<WorkspaceDiscoveryResult>> getResult)
+    {
+        _getResult = getResult;
+    }
+
+    public Task<WorkspaceDiscoveryResult> RunAsync(string repoRootPath, string workspacePath)
+    {
+        return _getResult((repoRootPath, workspacePath));
+    }
+
+    public static TestDiscoveryWorker FromResults(params (string RepoRootPath, string WorkspacePath, WorkspaceDiscoveryResult Result)[] results)
+    {
+        return new TestDiscoveryWorker(((string RepoRootPath, string WorkspacePath) input) =>
+        {
+            foreach (var set in results)
+            {
+                if (set.RepoRootPath == input.RepoRootPath &&
+                    set.WorkspacePath == input.WorkspacePath)
+                {
+                    return Task.FromResult(set.Result);
+                }
+            }
+
+            throw new NotImplementedException($"No saved response for {input}");
+        });
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/TestUpdaterWorker.cs

@@ -0,0 +1,39 @@
+using NuGetUpdater.Core.Updater;
+
+namespace NuGetUpdater.Core.Test;
+
+internal class TestUpdaterWorker : IUpdaterWorker
+{
+    private readonly Func<(string, string, string, string, string, bool), Task<UpdateOperationResult>> _getResult;
+
+    public TestUpdaterWorker(Func<(string, string, string, string, string, bool), Task<UpdateOperationResult>> getResult)
+    {
+        _getResult = getResult;
+    }
+
+    public Task<UpdateOperationResult> RunAsync(string repoRootPath, string workspacePath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive)
+    {
+        return _getResult((repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive));
+    }
+
+    public static TestUpdaterWorker FromResults(params (string RepoRootPath, string WorkspacePath, string DependencyName, string PreviousDependencyVersion, string NewDependencyVersion, bool IsTransitive, UpdateOperationResult Result)[] results)
+    {
+        return new TestUpdaterWorker(((string RepoRootPath, string WorkspacePath, string DependencyName, string PreviousDependencyVersion, string NewDependencyVersion, bool IsTransitive) input) =>
+        {
+            foreach (var set in results)
+            {
+                if (set.RepoRootPath == input.RepoRootPath &&
+                    set.WorkspacePath == input.WorkspacePath &&
+                    set.DependencyName == input.DependencyName &&
+                    set.PreviousDependencyVersion == input.PreviousDependencyVersion &&
+                    set.NewDependencyVersion == input.NewDependencyVersion &&
+                    set.IsTransitive == input.IsTransitive)
+                {
+                    return Task.FromResult(set.Result);
+                }
+            }
+
+            throw new NotImplementedException($"No saved response for {input}");
+        });
+    }
+}

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

@@ -6,18 +6,27 @@ public class PackagesConfigUpdaterTests : TestBase
 {
     [Theory]
     [MemberData(nameof(PackagesDirectoryPathTestData))]
-    public void PathToPackagesDirectoryCanBeDetermined(string projectContents, string dependencyName, string dependencyVersion, string expectedPackagesDirectoryPath)
+    public async Task PathToPackagesDirectoryCanBeDetermined(string projectContents, string? packagesConfigContents, string dependencyName, string dependencyVersion, string expectedPackagesDirectoryPath)
     {
+        using var tempDir = new TemporaryDirectory();
+        string? packagesConfigPath = null;
+        if (packagesConfigContents is not null)
+        {
+            packagesConfigPath = Path.Join(tempDir.DirectoryPath, "packages.config");
+            await File.WriteAllTextAsync(packagesConfigPath, packagesConfigContents);
+        }
+
         var projectBuildFile = ProjectBuildFile.Parse("/", "project.csproj", projectContents);
-        var actualPackagesDirectorypath = PackagesConfigUpdater.GetPathToPackagesDirectory(projectBuildFile, dependencyName, dependencyVersion, "packages.config");
+        var actualPackagesDirectorypath = PackagesConfigUpdater.GetPathToPackagesDirectory(projectBuildFile, dependencyName, dependencyVersion, packagesConfigPath);
         Assert.Equal(expectedPackagesDirectoryPath, actualPackagesDirectorypath);
     }
 
-    public static IEnumerable<object[]> PackagesDirectoryPathTestData()
+    public static IEnumerable<object?[]> PackagesDirectoryPathTestData()
     {
         // project with namespace
         yield return
         [
+            // project contents
             """
             <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <ItemGroup>
@@ -28,14 +37,20 @@ public class PackagesConfigUpdaterTests : TestBase
               </ItemGroup>
             </Project>
             """,
+            // packages.config contents
+            null,
+            // dependency name
             "Newtonsoft.Json",
+            // dependency version
             "7.0.1",
+            // expected packages directory path
             "../packages"
         ];
 
         // project without namespace
         yield return
         [
+            // project contents
             """
             <Project>
               <ItemGroup>
@@ -46,14 +61,20 @@ public class PackagesConfigUpdaterTests : TestBase
               </ItemGroup>
             </Project>
             """,
+            // packages.config contents
+            null,
+            // dependency name
             "Newtonsoft.Json",
+            // dependency version
             "7.0.1",
+            // expected packages directory path
             "../packages"
         ];
 
         // project with non-standard packages path
         yield return
         [
+            // project contents
             """
             <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <ItemGroup>
@@ -64,9 +85,89 @@ public class PackagesConfigUpdaterTests : TestBase
               </ItemGroup>
             </Project>
             """,
+            // packages.config contents
+            null,
+            // dependency name
             "Newtonsoft.Json",
+            // dependency version
             "7.0.1",
+            // expected packages directory path
             "../not-a-path-you-would-expect"
         ];
+
+        // project without expected packages path, but has others
+        yield return
+        [
+            // project contents
+            """
+            <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+              <ItemGroup>
+                <Reference Include="Some.Other.Package, Version=1.2.3.4, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+                  <HintPath>..\..\..\still-a-usable-path\Some.Other.Package.1.2.3\lib\net45\Some.Other.Package.dll</HintPath>
+                  <Private>True</Private>
+                </Reference>
+              </ItemGroup>
+            </Project>
+            """,
+            // packages.config contents
+            """
+            <packages>
+              <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net45" />
+            </packages>
+            """,
+            // dependency name
+            "Newtonsoft.Json",
+            // dependency version
+            "7.0.1",
+            // expected packages directory path
+            "../../../still-a-usable-path"
+        ];
+
+        // project without expected package, but exists in packages.config, default is returned
+        yield return
+        [
+            // project contents
+            """
+            <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+              <ItemGroup>
+              </ItemGroup>
+            </Project>
+            """,
+            // packages.config contents
+            """
+            <packages>
+              <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net45" />
+            </packages>
+            """,
+            // dependency name
+            "Newtonsoft.Json",
+            // dependency version
+            "7.0.1",
+            // expected packages directory path
+            "../packages"
+        ];
+
+        // project without expected package and not in packages.config
+        yield return
+        [
+            // project contents
+            """
+            <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+              <ItemGroup>
+              </ItemGroup>
+            </Project>
+            """,
+            // packages.config contents
+            """
+            <packages>
+            </packages>
+            """,
+            // dependency name
+            "Newtonsoft.Json",
+            // dependency version
+            "7.0.1",
+            // expected packages directory path
+            null
+        ];
     }
 }