dependabot-nuget 0.251.0 → 0.253.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/NuGetHelper.cs

@@ -1,4 +1,4 @@
-using System.IO;
+using System.Diagnostics.CodeAnalysis;
 
 namespace NuGetUpdater.Core;
 
@@ -6,10 +6,33 @@ internal static class NuGetHelper
 {
     internal const string PackagesConfigFileName = "packages.config";
 
-    public static bool HasPackagesConfigFile(string projectPath)
+    public static bool TryGetPackagesConfigFile(string projectPath, [NotNullWhen(returnValue: true)] out string? packagesConfigPath)
     {
         var projectDirectory = Path.GetDirectoryName(projectPath);
-        var packagesConfigPath = PathHelper.JoinPath(projectDirectory, PackagesConfigFileName);
-        return File.Exists(packagesConfigPath);
+
+        packagesConfigPath = PathHelper.JoinPath(projectDirectory, PackagesConfigFileName);
+        if (File.Exists(packagesConfigPath))
+        {
+            return true;
+        }
+
+        packagesConfigPath = null;
+        return false;
+    }
+
+    internal static async Task<bool> DownloadNuGetPackagesAsync(string repoRoot, string projectPath, IReadOnlyCollection<Dependency> packages, Logger logger)
+    {
+        var tempDirectory = Directory.CreateTempSubdirectory("msbuild_sdk_restore_");
+        try
+        {
+            var tempProjectPath = await MSBuildHelper.CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, "netstandard2.0", packages, usePackageDownload: true);
+            var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", $"restore \"{tempProjectPath}\"");
+
+            return exitCode == 0;
+        }
+        finally
+        {
+            tempDirectory.Delete(recursive: true);
+        }
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/PathHelper.cs

@@ -34,20 +34,11 @@ internal static class PathHelper
     public static string GetFullPathFromRelative(string rootPath, string relativePath)
         => Path.GetFullPath(JoinPath(rootPath, relativePath.NormalizePathToUnix()));
 
-    /// <summary>
-    /// Check in every directory from <paramref name="initialPath"/> up to <paramref name="rootPath"/> for the file specified in <paramref name="fileName"/>.
-    /// </summary>
-    /// <returns>The path of the found file or null.</returns>
-    public static string? GetFileInDirectoryOrParent(string initialPath, string rootPath, string fileName, bool caseSensitive = true)
+    public static string[] GetAllDirectoriesToRoot(string initialDirectoryPath, string rootDirectoryPath)
     {
-        if (File.Exists(initialPath))
-        {
-            initialPath = Path.GetDirectoryName(initialPath)!;
-        }
-
         var candidatePaths = new List<string>();
-        var rootDirectory = new DirectoryInfo(rootPath);
-        var candidateDirectory = new DirectoryInfo(initialPath);
+        var rootDirectory = new DirectoryInfo(rootDirectoryPath);
+        var candidateDirectory = new DirectoryInfo(initialDirectoryPath);
         while (candidateDirectory.FullName != rootDirectory.FullName)
         {
             candidatePaths.Add(candidateDirectory.FullName);
@@ -58,8 +49,22 @@ internal static class PathHelper
             }
         }
 
-        candidatePaths.Add(rootPath);
+        candidatePaths.Add(rootDirectoryPath);
+        return candidatePaths.ToArray();
+    }
+
+    /// <summary>
+    /// Check in every directory from <paramref name="initialPath"/> up to <paramref name="rootPath"/> for the file specified in <paramref name="fileName"/>.
+    /// </summary>
+    /// <returns>The path of the found file or null.</returns>
+    public static string? GetFileInDirectoryOrParent(string initialPath, string rootPath, string fileName, bool caseSensitive = true)
+    {
+        if (File.Exists(initialPath))
+        {
+            initialPath = Path.GetDirectoryName(initialPath)!;
+        }
 
+        var candidatePaths = GetAllDirectoriesToRoot(initialPath, rootPath);
         foreach (var candidatePath in candidatePaths)
         {
             try

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

@@ -0,0 +1,135 @@
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
+
+using NuGetUpdater.Core.Discover;
+using NuGetUpdater.Core.Test.Utilities;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Discover;
+
+using TestFile = (string Path, string Content);
+
+public class DiscoveryWorkerTestBase
+{
+    protected static async Task TestDiscoveryAsync(
+        string workspacePath,
+        TestFile[] files,
+        ExpectedWorkspaceDiscoveryResult expectedResult)
+    {
+        var actualResult = await RunDiscoveryAsync(files, async directoryPath =>
+        {
+            var worker = new DiscoveryWorker(new Logger(verbose: true));
+            await worker.RunAsync(directoryPath, workspacePath, DiscoveryWorker.DiscoveryResultFileName);
+        });
+
+        ValidateWorkspaceResult(expectedResult, actualResult);
+    }
+
+    protected static void ValidateWorkspaceResult(ExpectedWorkspaceDiscoveryResult expectedResult, WorkspaceDiscoveryResult actualResult)
+    {
+        Assert.NotNull(actualResult);
+        Assert.Equal(expectedResult.FilePath.NormalizePathToUnix(), actualResult.FilePath.NormalizePathToUnix());
+        ValidateDirectoryPackagesProps(expectedResult.DirectoryPackagesProps, actualResult.DirectoryPackagesProps);
+        ValidateResultWithDependencies(expectedResult.GlobalJson, actualResult.GlobalJson);
+        ValidateResultWithDependencies(expectedResult.DotNetToolsJson, actualResult.DotNetToolsJson);
+        ValidateProjectResults(expectedResult.Projects, actualResult.Projects);
+        Assert.Equal(expectedResult.ExpectedProjectCount ?? expectedResult.Projects.Length, actualResult.Projects.Length);
+
+        return;
+
+        void ValidateResultWithDependencies(ExpectedDependencyDiscoveryResult? expectedResult, IDiscoveryResultWithDependencies? actualResult)
+        {
+            if (expectedResult is null)
+            {
+                Assert.Null(actualResult);
+                return;
+            }
+            else
+            {
+                Assert.NotNull(actualResult);
+            }
+
+            Assert.Equal(expectedResult.FilePath.NormalizePathToUnix(), actualResult.FilePath.NormalizePathToUnix());
+            ValidateDependencies(expectedResult.Dependencies, actualResult.Dependencies);
+            Assert.Equal(expectedResult.ExpectedDependencyCount ?? expectedResult.Dependencies.Length, actualResult.Dependencies.Length);
+        }
+
+        void ValidateProjectResults(ImmutableArray<ExpectedSdkProjectDiscoveryResult> expectedProjects, ImmutableArray<ProjectDiscoveryResult> actualProjects)
+        {
+            if (expectedProjects.IsDefaultOrEmpty)
+            {
+                return;
+            }
+
+            foreach (var expectedProject in expectedProjects)
+            {
+                var actualProject = actualProjects.Single(p => p.FilePath.NormalizePathToUnix() == expectedProject.FilePath.NormalizePathToUnix());
+
+                Assert.Equal(expectedProject.FilePath.NormalizePathToUnix(), actualProject.FilePath.NormalizePathToUnix());
+                AssertEx.Equal(expectedProject.Properties, actualProject.Properties, PropertyComparer.Instance);
+                AssertEx.Equal(expectedProject.TargetFrameworks, actualProject.TargetFrameworks);
+                AssertEx.Equal(expectedProject.ReferencedProjectPaths.Select(PathHelper.NormalizePathToUnix), actualProject.ReferencedProjectPaths.Select(PathHelper.NormalizePathToUnix));
+                ValidateDependencies(expectedProject.Dependencies, actualProject.Dependencies);
+                Assert.Equal(expectedProject.ExpectedDependencyCount ?? expectedProject.Dependencies.Length, actualProject.Dependencies.Length);
+            }
+        }
+
+        void ValidateDirectoryPackagesProps(ExpectedDirectoryPackagesPropsDiscovertyResult? expected, DirectoryPackagesPropsDiscoveryResult? actual)
+        {
+            ValidateResultWithDependencies(expected, actual);
+            Assert.Equal(expected?.IsTransitivePinningEnabled, actual?.IsTransitivePinningEnabled);
+        }
+
+        void ValidateDependencies(ImmutableArray<Dependency> expectedDependencies, ImmutableArray<Dependency> actualDependencies)
+        {
+            if (expectedDependencies.IsDefault)
+            {
+                return;
+            }
+
+            foreach (var expectedDependency in expectedDependencies)
+            {
+                var actualDependency = actualDependencies.Single(d => d.Name == expectedDependency.Name);
+                Assert.Equal(expectedDependency.Name, actualDependency.Name);
+                Assert.Equal(expectedDependency.Version, actualDependency.Version);
+                Assert.Equal(expectedDependency.Type, actualDependency.Type);
+                AssertEx.Equal(expectedDependency.TargetFrameworks, actualDependency.TargetFrameworks);
+                Assert.Equal(expectedDependency.IsDirect, actualDependency.IsDirect);
+                Assert.Equal(expectedDependency.IsTransitive, actualDependency.IsTransitive);
+            }
+        }
+    }
+
+    protected static async Task<WorkspaceDiscoveryResult> RunDiscoveryAsync(TestFile[] files, Func<string, Task> action)
+    {
+        // write initial files
+        using var temporaryDirectory = await TemporaryDirectory.CreateWithContentsAsync(files);
+
+        // run discovery
+        await action(temporaryDirectory.DirectoryPath);
+
+        // gather results
+        var resultPath = Path.Join(temporaryDirectory.DirectoryPath, DiscoveryWorker.DiscoveryResultFileName);
+        var resultJson = await File.ReadAllTextAsync(resultPath);
+        return JsonSerializer.Deserialize<WorkspaceDiscoveryResult>(resultJson, DiscoveryWorker.SerializerOptions)!;
+    }
+
+    internal class PropertyComparer : IEqualityComparer<Property>
+    {
+        public static PropertyComparer Instance { get; } = new();
+
+        public bool Equals(Property? x, Property? y)
+        {
+            return x?.Name == y?.Name &&
+                   x?.Value == y?.Value &&
+                   x?.SourceFilePath.NormalizePathToUnix() == y?.SourceFilePath.NormalizePathToUnix();
+        }
+
+        public int GetHashCode([DisallowNull] Property obj)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

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

@@ -0,0 +1,91 @@
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Discover;
+
+public partial class DiscoveryWorkerTests
+{
+    public class DotNetToolsJson : DiscoveryWorkerTestBase
+    {
+        [Fact]
+        public async Task DiscoversDependencies()
+        {
+            await TestDiscoveryAsync(
+                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()
+                {
+                    FilePath = "",
+                    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()
+        {
+            await TestDiscoveryAsync(
+                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()
+                {
+                    FilePath = "",
+                    DotNetToolsJson = new()
+                    {
+                        FilePath = ".config/dotnet-tools.json",
+                        IsSuccess = false,
+                        ExpectedDependencyCount = 0,
+                    },
+                    ExpectedProjectCount = 0,
+                });
+        }
+    }
+}

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

@@ -0,0 +1,71 @@
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Discover;
+
+public partial class DiscoveryWorkerTests
+{
+    public class GlobalJson : DiscoveryWorkerTestBase
+    {
+        [Fact]
+        public async Task DiscoversDependencies()
+        {
+            await TestDiscoveryAsync(
+                workspacePath: "",
+                files: [
+                    ("global.json", """
+                        {
+                          "sdk": {
+                            "version": "2.2.104"
+                          },
+                          "msbuild-sdks": {
+                            "Microsoft.Build.Traversal": "1.0.45"
+                          }
+                        }
+                        """),
+                ],
+                expectedResult: new()
+                {
+                    FilePath = "",
+                    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()
+        {
+            await TestDiscoveryAsync(
+                workspacePath: "",
+                files: [
+                    ("global.json", """
+                        {
+                          "sdk": {
+                            "version": "2.2.104",
+                          },
+                          "msbuild-sdks": {
+                            "Microsoft.Build.Traversal": "1.0.45"
+                          }
+                        }
+                        """),
+                ],
+                expectedResult: new()
+                {
+                    FilePath = "",
+                    GlobalJson = new()
+                    {
+                        FilePath = "global.json",
+                        IsSuccess = false,
+                        ExpectedDependencyCount = 0,
+                    },
+                    ExpectedProjectCount = 0,
+                });
+        }
+    }
+}

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

@@ -0,0 +1,67 @@
+using System.Collections.Immutable;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Discover;
+
+public partial class DiscoveryWorkerTests
+{
+    public class PackagesConfig : DiscoveryWorkerTestBase
+    {
+        [Fact]
+        public async Task DiscoversDependencies()
+        {
+            await TestDiscoveryAsync(
+                workspacePath: "",
+                files: [
+                    ("packages.config", """
+                        <?xml version="1.0" encoding="utf-8"?>
+                        <packages>
+                          <package id="Microsoft.CodeDom.Providers.DotNetCompilerPlatform" version="1.0.0" targetFramework="net46" />
+                          <package id="Microsoft.Net.Compilers" version="1.0.1" targetFramework="net46" developmentDependency="true" />
+                          <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net46" />
+                          <package id="Microsoft.Web.Xdt" version="2.1.1" targetFramework="net46" />
+                          <package id="Newtonsoft.Json" version="8.0.3" allowedVersions="[8,10)" targetFramework="net46" />
+                          <package id="NuGet.Core" version="2.11.1" targetFramework="net46" />
+                          <package id="NuGet.Server" version="2.11.2" targetFramework="net46" />
+                          <package id="RouteMagic" version="1.3" targetFramework="net46" />
+                          <package id="WebActivatorEx" version="2.1.0" targetFramework="net46" />
+                        </packages>
+                        """),
+                    ("myproj.csproj", """
+                        <Project>
+                          <PropertyGroup>
+                            <TargetFramework>net46</TargetFramework>
+                          </PropertyGroup>
+                        </Project>
+                        """)
+                ],
+                expectedResult: new()
+                {
+                    FilePath = "",
+                    Projects = [
+                        new()
+                        {
+                            FilePath = "myproj.csproj",
+                            Properties = [
+                                new("TargetFramework", "net46", "myproj.csproj"),
+                            ],
+                            TargetFrameworks = ["net46"],
+                            Dependencies = [
+                                new("Microsoft.NETFramework.ReferenceAssemblies", "1.0.3", DependencyType.Unknown, TargetFrameworks: ["net46"], IsTransitive: true),
+                                new("Microsoft.CodeDom.Providers.DotNetCompilerPlatform", "1.0.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Microsoft.Net.Compilers", "1.0.1", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Microsoft.Web.Infrastructure", "1.0.0.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Microsoft.Web.Xdt", "2.1.1", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Newtonsoft.Json", "8.0.3", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("NuGet.Core", "2.11.1", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("NuGet.Server", "2.11.2", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("RouteMagic", "1.3", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("WebActivatorEx", "2.1.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                            ],
+                        }
+                    ],
+                });
+        }
+    }
+}