dependabot-nuget 0.240.0 → 0.242.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/FrameworkChecker/SupportedFrameworkFacts.cs

@@ -0,0 +1,68 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Linq;
+
+using NuGet.Frameworks;
+
+using NuGetGallery.Frameworks;
+
+using Xunit;
+
+using static NuGet.Frameworks.FrameworkConstants;
+using static NuGet.Frameworks.FrameworkConstants.CommonFrameworks;
+
+namespace NuGetUpdater.Core.Test.FrameworkChecker;
+
+public class SupportedFrameworksFacts
+{
+    private static readonly NuGetFramework Win = new NuGetFramework(FrameworkIdentifiers.Windows, EmptyVersion);
+    private static readonly NuGetFramework WinRt = new NuGetFramework(FrameworkIdentifiers.WinRT, EmptyVersion);
+
+    // See: https://docs.microsoft.com/en-us/dotnet/standard/frameworks#deprecated-target-frameworks
+    private readonly HashSet<NuGetFramework> DeprecatedFrameworks = new HashSet<NuGetFramework>() {
+            AspNet, AspNet50, AspNetCore, AspNetCore50,
+            Dnx, Dnx45, Dnx451, Dnx452, DnxCore, DnxCore50,
+            DotNet, DotNet50, DotNet51, DotNet52, DotNet53, DotNet54, DotNet55, DotNet56,
+            NetCore50,
+            Win, Win8, Win81, Win10,
+            WinRt
+        };
+    // The following frameworks were included in NuGet.Client code but they were not official framework releases.
+    private readonly HashSet<NuGetFramework> UnofficialFrameworks = new HashSet<NuGetFramework>()
+        {
+            NetStandard17, NetStandardApp15
+        };
+
+    [Fact]
+    public void SupportedFrameworksContainsCommonFrameworksWithNoDeprecatedFrameworks()
+    {
+        var fields = typeof(FrameworkConstants.CommonFrameworks)
+            .GetFields()
+            .Where(f => f.FieldType == typeof(NuGetFramework))
+            .ToList();
+
+        Assert.True(fields.Count > 0);
+
+        var supportedFrameworks = new HashSet<NuGetFramework>(SupportedFrameworks.AllSupportedNuGetFrameworks);
+
+        foreach (var field in fields)
+        {
+            var framework = (NuGetFramework)field.GetValue(null);
+
+            if (DeprecatedFrameworks.Contains(framework))
+            {
+                Assert.False(supportedFrameworks.Contains(framework), $"SupportedFrameworks should not contain the deprecated framework {field.Name}.");
+            }
+            else if (UnofficialFrameworks.Contains(framework))
+            {
+                Assert.False(supportedFrameworks.Contains(framework), $"SupportedFrameworks should not contain the unofficial framework {field.Name}.");
+            }
+            else
+            {
+                Assert.True(supportedFrameworks.Contains(framework), $"SupportedFrameworks is missing {field.Name} constant from CommonFrameworks.");
+            }
+        }
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/NuGetUpdater.Core.Test.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>$(CommonTargetFramework)</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\NuGetUpdater.Core\NuGetUpdater.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="..\xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+</Project>

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

@@ -0,0 +1,36 @@
+using System;
+using System.IO;
+
+namespace NuGetUpdater.Core.Test;
+
+public sealed class TemporaryDirectory : IDisposable
+{
+    public string DirectoryPath { get; }
+
+    public TemporaryDirectory()
+    {
+        var parentDir = Path.GetDirectoryName(GetType().Assembly.Location)!;
+        var tempDirName = $"nuget-updater-{Guid.NewGuid():d}";
+        DirectoryPath = Path.Combine(parentDir, "test-data", tempDirName);
+        Directory.CreateDirectory(DirectoryPath);
+    }
+
+    public void Dispose()
+    {
+        Directory.Delete(DirectoryPath, true);
+    }
+
+    public static TemporaryDirectory CreateWithContents(params (string Path, string Contents)[] fileContents)
+    {
+        var temporaryDirectory = new TemporaryDirectory();
+        foreach (var (path, contents) in fileContents)
+        {
+            var fullPath = Path.Combine(temporaryDirectory.DirectoryPath, path);
+            var fullDirectory = Path.GetDirectoryName(fullPath)!;
+            Directory.CreateDirectory(fullDirectory);
+            File.WriteAllText(fullPath, contents);
+        }
+
+        return temporaryDirectory;
+    }
+}

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

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+using Microsoft.Language.Xml;
+
+namespace NuGetUpdater.Core.Test;
+
+static class TestExtensions
+{
+    public static XElement ToXElement(this IXmlElementSyntax xml) => XElement.Parse(xml.ToFullString());
+
+    public static Dictionary<string, XElement> ToXElementDictionary(this Dictionary<string, IXmlElementSyntax> dictionary)
+        => dictionary.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToXElement());
+}

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

@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Update;
+
+public class PackagesConfigUpdaterTests
+{
+    public PackagesConfigUpdaterTests()
+    {
+        MSBuildHelper.RegisterMSBuild();
+    }
+
+    [Theory]
+    [MemberData(nameof(PackagesDirectoryPathTestData))]
+    public void PathToPackagesDirectoryCanBeDetermined(string projectContents, string dependencyName, string dependencyVersion, string expectedPackagesDirectoryPath)
+    {
+        var projectBuildFile = ProjectBuildFile.Parse("/", "project.csproj", projectContents);
+        var actualPackagesDirectorypath = PackagesConfigUpdater.GetPathToPackagesDirectory(projectBuildFile, dependencyName, dependencyVersion);
+        Assert.Equal(expectedPackagesDirectoryPath, actualPackagesDirectorypath);
+    }
+
+    public static IEnumerable<object[]> PackagesDirectoryPathTestData()
+    {
+        // project with namespace
+        yield return new object[]
+        {
+            """
+            <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+              <ItemGroup>
+                <Reference Include="Newtonsoft.Json, Version=7.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+                  <HintPath>..\packages\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+                  <Private>True</Private>
+                </Reference>
+              </ItemGroup>
+            </Project>
+            """,
+            "Newtonsoft.Json",
+            "7.0.1",
+            @"..\packages"
+        };
+
+        // project without namespace
+        yield return new object[]
+        {
+            """
+            <Project>
+              <ItemGroup>
+                <Reference Include="Newtonsoft.Json, Version=7.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+                  <HintPath>..\packages\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+                  <Private>True</Private>
+                </Reference>
+              </ItemGroup>
+            </Project>
+            """,
+            "Newtonsoft.Json",
+            "7.0.1",
+            @"..\packages"
+        };
+
+        // project with non-standard packages path
+        yield return new object[]
+        {
+            """
+            <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+              <ItemGroup>
+                <Reference Include="Newtonsoft.Json, Version=7.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+                  <HintPath>..\not-a-path-you-would-expect\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+                  <Private>True</Private>
+                </Reference>
+              </ItemGroup>
+            </Project>
+            """,
+            "Newtonsoft.Json",
+            "7.0.1",
+            @"..\not-a-path-you-would-expect"
+        };
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorker.DirsProj.cs

@@ -0,0 +1,201 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Update;
+
+public partial class UpdateWorkerTests
+{
+    public class DirsProj : UpdateWorkerTestBase
+    {
+        public DirsProj()
+        {
+            MSBuildHelper.RegisterMSBuild();
+        }
+
+        [Fact]
+        public async Task UpdateSingleDependencyInDirsProj()
+        {
+            await TestUpdateForDirsProj("Newtonsoft.Json", "9.0.1", "13.0.1",
+                // initial
+                projectContents: """
+                <Project Sdk="Microsoft.Build.NoTargets">
+
+                  <ItemGroup>
+                    <ProjectReference Include="src/test-project.csproj" />
+                  </ItemGroup>
+
+                </Project>
+                """,
+                additionalFiles: new (string Path, string Content)[]
+                {
+                    ("src/test-project.csproj",
+                      """
+                      <Project Sdk="Microsoft.NET.Sdk">
+                        <PropertyGroup>
+                          <TargetFramework>netstandard2.0</TargetFramework>
+                        </PropertyGroup>
+
+                        <ItemGroup>
+                          <PackageReference Include="Newtonsoft.Json" Version="9.0.1" />
+                        </ItemGroup>
+                      </Project>
+                      """)
+                },
+                // expected
+                expectedProjectContents: """
+                <Project Sdk="Microsoft.Build.NoTargets">
+
+                  <ItemGroup>
+                    <ProjectReference Include="src/test-project.csproj" />
+                  </ItemGroup>
+
+                </Project>
+                """,
+                additionalFilesExpected: new (string Path, string Content)[]
+                {
+                    ("src/test-project.csproj",
+                      """
+                      <Project Sdk="Microsoft.NET.Sdk">
+                        <PropertyGroup>
+                          <TargetFramework>netstandard2.0</TargetFramework>
+                        </PropertyGroup>
+
+                        <ItemGroup>
+                          <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+                        </ItemGroup>
+                      </Project>
+                      """)
+                });
+        }
+
+        [Fact]
+        public async Task Update_MissingFileDoesNotThrow()
+        {
+            await TestUpdateForDirsProj("Newtonsoft.Json", "9.0.1", "13.0.1",
+                projectContents: """
+                <Project Sdk="Microsoft.Build.Traversal">
+                  <ItemGroup>
+                    <ProjectReference Include="private\dirs.proj" />
+                  </ItemGroup>
+                </Project>
+                """,
+                expectedProjectContents: """
+                <Project Sdk="Microsoft.Build.Traversal">
+                  <ItemGroup>
+                    <ProjectReference Include="private\dirs.proj" />
+                  </ItemGroup>
+                </Project>
+                """,
+                additionalFiles: []);
+        }
+
+        [Fact]
+        public async Task UpdateSingleDependencyInNestedDirsProj()
+        {
+            await TestUpdateForDirsProj("Newtonsoft.Json", "9.0.1", "13.0.1",
+                // initial
+                projectContents: """
+                <Project Sdk="Microsoft.Build.NoTargets">
+
+                  <ItemGroup>
+                    <ProjectReference Include="src/dirs.proj" />
+                  </ItemGroup>
+
+                </Project>
+                """,
+                additionalFiles: new (string Path, string Content)[]
+                {
+                    ("src/dirs.proj",
+                      """
+                      <Project Sdk="Microsoft.Build.NoTargets">
+
+                        <ItemGroup>
+                          <ProjectReference Include="test-project/test-project.csproj" />
+                        </ItemGroup>
+
+                      </Project>
+                      """),
+                    ("src/test-project/test-project.csproj",
+                      """
+                      <Project Sdk="Microsoft.NET.Sdk">
+                        <PropertyGroup>
+                          <TargetFramework>netstandard2.0</TargetFramework>
+                        </PropertyGroup>
+
+                        <ItemGroup>
+                          <PackageReference Include="Newtonsoft.Json" Version="9.0.1" />
+                        </ItemGroup>
+                      </Project>
+                      """)
+                },
+                // expected
+                expectedProjectContents: """
+                <Project Sdk="Microsoft.Build.NoTargets">
+
+                  <ItemGroup>
+                    <ProjectReference Include="src/dirs.proj" />
+                  </ItemGroup>
+
+                </Project>
+                """,
+                additionalFilesExpected: new (string Path, string Content)[]
+                {
+                    ("src/dirs.proj",
+                      """
+                      <Project Sdk="Microsoft.Build.NoTargets">
+
+                        <ItemGroup>
+                          <ProjectReference Include="test-project/test-project.csproj" />
+                        </ItemGroup>
+
+                      </Project>
+                      """),
+                    ("src/test-project/test-project.csproj",
+                      """
+                      <Project Sdk="Microsoft.NET.Sdk">
+                        <PropertyGroup>
+                          <TargetFramework>netstandard2.0</TargetFramework>
+                        </PropertyGroup>
+
+                        <ItemGroup>
+                          <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+                        </ItemGroup>
+                      </Project>
+                      """)
+                });
+        }
+
+        static async Task TestUpdateForDirsProj(
+            string dependencyName,
+            string oldVersion,
+            string newVersion,
+            string projectContents,
+            string expectedProjectContents,
+            bool isTransitive = false,
+            (string Path, string Content)[]? additionalFiles = null,
+            (string Path, string Content)[]? additionalFilesExpected = null)
+        {
+            additionalFiles ??= Array.Empty<(string Path, string Content)>();
+            additionalFilesExpected ??= Array.Empty<(string Path, string Content)>();
+
+            var projectName = "dirs";
+            var projectFileName = $"{projectName}.proj";
+            var testFiles = additionalFiles.Prepend((projectFileName, projectContents)).ToArray();
+
+            var actualResult = await RunUpdate(testFiles, async (temporaryDirectory) =>
+            {
+                var projectPath = Path.Combine(temporaryDirectory, projectFileName);
+                var worker = new UpdaterWorker(new Logger(verbose: true));
+                await worker.RunAsync(temporaryDirectory, projectPath, dependencyName, oldVersion, newVersion, isTransitive);
+            });
+
+            var expectedResult = additionalFilesExpected.Prepend((projectFileName, expectedProjectContents)).ToArray();
+
+            AssertContainsFiles(expectedResult, actualResult);
+        }
+    }
+}

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

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Update;
+
+public abstract class UpdateWorkerTestBase
+{
+    protected static Task TestNoChangeforProject(
+        string dependencyName,
+        string oldVersion,
+        string newVersion,
+        string projectContents,
+        bool isTransitive = false,
+        (string Path, string Content)[]? additionalFiles = null,
+        string projectFilePath = "test-project.csproj")
+        => TestUpdateForProject(dependencyName, oldVersion, newVersion, (projectFilePath, projectContents), expectedProjectContents: projectContents, isTransitive, additionalFiles, additionalFilesExpected: additionalFiles);
+
+    protected static Task TestUpdateForProject(
+        string dependencyName,
+        string oldVersion,
+        string newVersion,
+        string projectContents,
+        string expectedProjectContents,
+        bool isTransitive = false,
+        (string Path, string Content)[]? additionalFiles = null,
+        (string Path, string Content)[]? additionalFilesExpected = null,
+        string projectFilePath = "test-project.csproj")
+    {
+        var projectFile = (Path: projectFilePath, Content: projectContents);
+        return TestUpdateForProject(dependencyName, oldVersion, newVersion, projectFile, expectedProjectContents, isTransitive, additionalFiles, additionalFilesExpected);
+    }
+
+    protected static async Task TestUpdateForProject(
+        string dependencyName,
+        string oldVersion,
+        string newVersion,
+        (string Path, string Content) projectFile,
+        string expectedProjectContents,
+        bool isTransitive = false,
+        (string Path, string Content)[]? additionalFiles = null,
+        (string Path, string Content)[]? additionalFilesExpected = null)
+    {
+        additionalFiles ??= Array.Empty<(string Path, string Content)>();
+        additionalFilesExpected ??= Array.Empty<(string Path, string Content)>();
+
+        var projectFilePath = projectFile.Path;
+        var projectName = Path.GetFileNameWithoutExtension(projectFilePath);
+        var slnName = "test-solution.sln";
+        var slnContent = $$"""
+            Microsoft Visual Studio Solution File, Format Version 12.00
+            # Visual Studio 14
+            VisualStudioVersion = 14.0.22705.0
+            MinimumVisualStudioVersion = 10.0.40219.1
+            Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "{{projectName}}", "{{projectFilePath}}", "{782E0C0A-10D3-444D-9640-263D03D2B20C}"
+            EndProject
+            Global
+              GlobalSection(SolutionConfigurationPlatforms) = preSolution
+                Debug|Any CPU = Debug|Any CPU
+                Release|Any CPU = Release|Any CPU
+              EndGlobalSection
+              GlobalSection(ProjectConfigurationPlatforms) = postSolution
+                {782E0C0A-10D3-444D-9640-263D03D2B20C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+                {782E0C0A-10D3-444D-9640-263D03D2B20C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+                {782E0C0A-10D3-444D-9640-263D03D2B20C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+                {782E0C0A-10D3-444D-9640-263D03D2B20C}.Release|Any CPU.Build.0 = Release|Any CPU
+              EndGlobalSection
+              GlobalSection(SolutionProperties) = preSolution
+                HideSolutionNode = FALSE
+              EndGlobalSection
+            EndGlobal
+            """;
+        var testFiles = new[] { (slnName, slnContent), projectFile }.Concat(additionalFiles).ToArray();
+
+        var actualResult = await RunUpdate(testFiles, async (temporaryDirectory) =>
+        {
+            var slnPath = Path.Combine(temporaryDirectory, slnName);
+            var worker = new UpdaterWorker(new Logger(verbose: true));
+            await worker.RunAsync(temporaryDirectory, slnPath, dependencyName, oldVersion, newVersion, isTransitive);
+        });
+
+        var expectedResult = additionalFilesExpected.Prepend((projectFilePath, expectedProjectContents)).ToArray();
+
+        AssertContainsFiles(expectedResult, actualResult);
+    }
+
+    protected static async Task<(string Path, string Content)[]> RunUpdate((string Path, string Content)[] files, Func<string, Task> action)
+    {
+        // write initial files
+        using var tempDir = new TemporaryDirectory();
+        foreach (var file in files)
+        {
+            var localPath = file.Path.StartsWith("/") ? file.Path[1..] : file.Path; // remove path rooting character
+            var filePath = Path.Combine(tempDir.DirectoryPath, localPath);
+            var directoryPath = Path.GetDirectoryName(filePath);
+            Directory.CreateDirectory(directoryPath!);
+            await File.WriteAllTextAsync(filePath, file.Content);
+        }
+
+        // run update
+        await action(tempDir.DirectoryPath);
+
+        // gather results
+        var expectedFiles = new HashSet<string>(files.Select(f => f.Path));
+        var result = new List<(string Path, string Content)>();
+        foreach (var file in Directory.GetFiles(tempDir.DirectoryPath, "*.*", SearchOption.AllDirectories))
+        {
+            var localPath = file.StartsWith(tempDir.DirectoryPath)
+                ? file[tempDir.DirectoryPath.Length..]
+                : file; // how did this happen?
+            localPath = localPath.NormalizePathToUnix();
+            if (localPath.StartsWith('/'))
+            {
+                localPath = localPath[1..];
+            }
+
+            if (expectedFiles.Contains(localPath))
+            {
+                var content = await File.ReadAllTextAsync(file);
+                result.Add((localPath, content));
+            }
+        }
+
+        return result.ToArray();
+    }
+
+    protected static void AssertEqualFiles((string Path, string Content)[] expected, (string Path, string Content)[] actual)
+    {
+        Assert.Equal(expected.Length, actual.Length);
+        AssertContainsFiles(expected, actual);
+    }
+
+    protected static void AssertContainsFiles((string Path, string Content)[] expected, (string Path, string Content)[] actual)
+    {
+        var actualContents = actual.ToDictionary(pair => pair.Path, pair => pair.Content);
+        foreach (var expectedPair in expected)
+        {
+            var actualContent = actualContents[expectedPair.Path];
+            var expectedContent = expectedPair.Content;
+            Assert.Equal(expectedContent.Replace("\r", ""), actualContent.Replace("\r", "")); // normalize line endings
+        }
+    }
+}