dependabot-nuget 0.239.0 → 0.241.0

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

@@ -0,0 +1,122 @@
+// 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;
+using System.Collections.Generic;
+using System.Linq;
+
+using NuGet.Frameworks;
+
+using NuGetUpdater.Core.FrameworkChecker;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.FrameworkChecker;
+
+public class FrameworkCompatibilityServiceFacts
+{
+    private readonly FrameworkCompatibilityService _service;
+    private readonly IFrameworkCompatibilityProvider _compatibilityProvider = DefaultCompatibilityProvider.Instance;
+
+    public FrameworkCompatibilityServiceFacts()
+    {
+        _service = new FrameworkCompatibilityService();
+    }
+
+    [Fact]
+    public void NullPackageFrameworksThrowsArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => _service.GetCompatibleFrameworks(null));
+    }
+
+    [Fact]
+    public void EmptyPackageFrameworksReturnsEmptySet()
+    {
+        var result = _service.GetCompatibleFrameworks(new List<NuGetFramework>());
+
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public void UnknownSupportedPackageReturnsSetWithSameFramework()
+    {
+        var framework = NuGetFramework.Parse("net45-client");
+        var frameworks = new List<NuGetFramework>() { framework };
+        var compatible = _service.GetCompatibleFrameworks(frameworks);
+
+        Assert.False(framework.IsUnsupported);
+        Assert.Equal(expected: 1, compatible.Count);
+        Assert.Contains(framework, compatible);
+    }
+
+    [Theory]
+    [InlineData("1000")]
+    [InlineData("lib")]
+    [InlineData("nuget")]
+    public void UnsupportedPackageFrameworksReturnsEmptySet(string unsupportedFrameworkName)
+    {
+        var unsupportedFramework = NuGetFramework.Parse(unsupportedFrameworkName);
+
+        var result = _service.GetCompatibleFrameworks(new List<NuGetFramework>() { unsupportedFramework });
+
+        Assert.True(unsupportedFramework.IsUnsupported);
+        Assert.Equal(expected: 0, actual: result.Count);
+    }
+
+    [Theory]
+    [InlineData("portable-net45+sl4+win8+wp7")]
+    [InlineData("portable-net40+sl4")]
+    [InlineData("portable-net45+sl5+win8+wpa81+wp8")]
+    public void PCLPackageFrameworksReturnsEmptySet(string pclFrameworkName)
+    {
+        var portableFramework = NuGetFramework.Parse(pclFrameworkName);
+
+        var result = _service.GetCompatibleFrameworks(new List<NuGetFramework>() { portableFramework });
+
+        Assert.True(portableFramework.IsPCL);
+        Assert.Equal(expected: 0, actual: result.Count);
+    }
+
+    [Theory]
+    [InlineData("net5.0", "netcoreapp2.0", "win81")]
+    [InlineData("sl4", "netstandard1.2", "netmf")]
+    public void ValidPackageFrameworksReturnsFrameworksCompatibleForAtLeastOne(params string[] frameworkNames)
+    {
+        var frameworks = new List<NuGetFramework>();
+
+        foreach (var frameworkName in frameworkNames)
+        {
+            frameworks.Add(NuGetFramework.Parse(frameworkName));
+        }
+
+        var compatibleFrameworks = _service.GetCompatibleFrameworks(frameworks);
+
+        Assert.True(compatibleFrameworks.Count > 0);
+
+        foreach (var compatibleFramework in compatibleFrameworks)
+        {
+            var isCompatible = frameworks.Any(f => _compatibilityProvider.IsCompatible(compatibleFramework, f));
+
+            Assert.True(isCompatible);
+        }
+    }
+
+    [Theory]
+    [InlineData("net6.0-windows7.0", "net6.0-windows", "net6.0-windows7.0", "net7.0-windows", "net7.0-windows7.0")]
+    public void WindowsPlatformVersionsShouldContainAllSpecifiedFrameworks(string windowsDefaultVersionFramework, params string[] windowsProjectFrameworks)
+    {
+        var packageFramework = NuGetFramework.Parse(windowsDefaultVersionFramework);
+        var projectFrameworks = new HashSet<NuGetFramework>();
+
+        foreach (var frameworkName in windowsProjectFrameworks)
+        {
+            projectFrameworks.Add(NuGetFramework.Parse(frameworkName));
+        }
+
+        var compatibleFrameworks = _service.GetCompatibleFrameworks(new HashSet<NuGetFramework>() { packageFramework });
+        Assert.Equal(windowsProjectFrameworks.Length, compatibleFrameworks.Count);
+
+        var containsAllCompatibleFrameworks = compatibleFrameworks.All(cf => projectFrameworks.Contains(cf));
+        Assert.True(containsAllCompatibleFrameworks);
+    }
+}

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);
+        }
+    }
+}