DotnetPackageUpdateTests.cs

// 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.

#nullable disable

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using System.Xml.Linq;
using System.Xml.XPath;
using FluentAssertions;
using NuGet.CommandLine.Xplat.Tests;
using NuGet.Frameworks;
using NuGet.ProjectModel;
using NuGet.Test.Utility;
using NuGet.Versioning;
using Xunit;
using Xunit.Abstractions;

namespace Dotnet.Integration.Test
{
    [Collection(DotnetIntegrationCollection.Name)]
    public class DotnetPackageUpdateTests : IClassFixture<PackageSearchRunnerFixture>
    {
        private readonly DotnetIntegrationTestFixture _testFixture;
        private readonly ITestOutputHelper _testOutputHelper;
        private readonly IReadOnlyDictionary<string, string> _envVars;

        // The .NET SDK downloads reference assembly packages for target frameworks it can't find ref assemblies for
        // locally. Ideally this should be solved, so it's not necessary to download the packages every time the test
        // runs. At a minimum, this should be changed to use package source mapping, once update package supports PSM.
        private const string NugetConfigFormat = """
            <configuration>
              <packageSources>
                <clear />
                <add key="test" value="{0}" />
                <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
              </packageSources>
              <packageSourceMapping>
                <clear />
              </packageSourceMapping>
            </configuration>
            """;

        public DotnetPackageUpdateTests(DotnetIntegrationTestFixture testFixture, ITestOutputHelper testOutputHelper)
        {
            _testFixture = testFixture;
            _testOutputHelper = testOutputHelper;

            _envVars = new Dictionary<string, string>()
            {
                ["DOTNET_HOST_PATH"] = _testFixture.TestDotnetCli
            };
        }

        [Fact]
        public async Task SingleTfmProject_PackageVersionUpdated()
        {
            // Arrange
            using var testContext = new SimpleTestPathContext();
            File.WriteAllText(testContext.NuGetConfig, string.Format(NugetConfigFormat, testContext.PackageSource));

            var a1 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "1.0.0");
            var a2 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "2.0.0");

            SimpleTestPackageContext[] packages = [a1, a2];
            await SimpleTestPackageUtility.CreatePackagesAsync(testContext.PackageSource, packages);

            var csprojContents = """
                <Project Sdk="Microsoft.NET.Sdk">
                    <PropertyGroup>
                        <TargetFramework>net9.0</TargetFramework>
                    </PropertyGroup>
                    <ItemGroup>
                        <PackageReference Include="NuGet.Internal.Test.a" Version="1.0.0" />
                    </ItemGroup>
                </Project>
                """;
            var csprojPath = Path.Combine(testContext.SolutionRoot, "my.csproj");
            File.WriteAllText(csprojPath, csprojContents);

            // Act
            var result = _testFixture.RunDotnetExpectSuccess(
                workingDirectory: testContext.SolutionRoot,
                args: $"package update NuGet.Internal.Test.a",
                testOutputHelper: _testOutputHelper,
                environmentVariables: _envVars);

            // Assert
            result.ExitCode.Should().Be(0);

            string version = GetPackageReferenceVersion(csprojPath, "NuGet.Internal.Test.a");
            version.Should().Be("2.0.0");
        }

        [Fact]
        public async Task FileBasedApp()
        {
            using var pathContext = _testFixture.CreateSimpleTestPathContext();

            // Create packages.
            var a1 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "1.0.0");
            var a2 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "2.0.0");

            SimpleTestPackageContext[] packages = [a1, a2];
            await SimpleTestPackageUtility.CreatePackagesAsync(pathContext.PackageSource, packages);

            // Create the file-based app.
            var fbaDir = Path.Join(pathContext.SolutionRoot, "fba");
            Directory.CreateDirectory(fbaDir);

            var appFile = Path.Join(fbaDir, "app.cs");
            File.WriteAllText(appFile, """
                #:property PublishAot=false
                #:package NuGet.Internal.Test.a@1.0.0
                Console.WriteLine();
                """);

            // Update the package.
            _testFixture.RunDotnetExpectSuccess(fbaDir, "package update --file app.cs", testOutputHelper: _testOutputHelper, environmentVariables: _envVars);

            // Verify the full content of the modified .cs file.
            var modifiedContent = File.ReadAllText(appFile);
            _testOutputHelper.WriteLine("after:\n" + modifiedContent);
            Assert.Equal(
                """
                #:property PublishAot=false
                #:package NuGet.Internal.Test.a@2.0.0
                Console.WriteLine();
                """,
                modifiedContent);
        }

        [Fact]
        public async Task SingleTfmCpmProject_PackageVersionUpdated()
        {
            // Arrange
            using var testContext = new SimpleTestPathContext();
            File.WriteAllText(testContext.NuGetConfig, string.Format(NugetConfigFormat, testContext.PackageSource));

            var a1 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "1.0.0");
            var a2 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "2.0.0");

            SimpleTestPackageContext[] packages = [a1, a2];
            await SimpleTestPackageUtility.CreatePackagesAsync(testContext.PackageSource, packages);

            var csprojContents = """
                <Project Sdk="Microsoft.NET.Sdk">
                    <PropertyGroup>
                        <TargetFramework>net9.0</TargetFramework>
                    </PropertyGroup>
                    <ItemGroup>
                        <PackageReference Include="NuGet.Internal.Test.a" />
                    </ItemGroup>
                </Project>
                """;
            var csprojPath = Path.Combine(testContext.SolutionRoot, "my.csproj");
            File.WriteAllText(csprojPath, csprojContents);

            var packagesPropsContents = """
                <Project>
                    <PropertyGroup>
                        <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
                    </PropertyGroup>
                    <ItemGroup>
                        <PackageVersion Include="NuGet.Internal.Test.a" Version="1.0.0" />
                    </ItemGroup>
                </Project>
                """;
            var packagesPropsPath = Path.Combine(testContext.SolutionRoot, "Directory.Packages.props");
            File.WriteAllText(packagesPropsPath, packagesPropsContents);

            // Act
            var result = _testFixture.RunDotnetExpectSuccess(
                workingDirectory: testContext.SolutionRoot,
                args: $"package update NuGet.Internal.Test.a",
                testOutputHelper: _testOutputHelper,
                environmentVariables: _envVars);

            // Assert
            result.ExitCode.Should().Be(0);

            string packageReferenceVersion = GetPackageReferenceVersion(csprojPath, "NuGet.Internal.Test.a");
            packageReferenceVersion.Should().BeNullOrEmpty();

            string packageVersionVersion = GetPackageVersionVersion(csprojPath, "NuGet.Internal.Test.a");
            packageVersionVersion.Should().Be("2.0.0");
        }

        [Fact]
        public async Task MultiTfmProject_PackageVersionUpdated()
        {
            // Arrange
            using var testContext = new SimpleTestPathContext();
            File.WriteAllText(testContext.NuGetConfig, string.Format(NugetConfigFormat, testContext.PackageSource));

            var a1 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "1.0.0");
            var a2 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "2.0.0");

            SimpleTestPackageContext[] packages = [a1, a2];
            await SimpleTestPackageUtility.CreatePackagesAsync(testContext.PackageSource, packages);

            var csprojContents = """
                <Project Sdk="Microsoft.NET.Sdk">
                    <PropertyGroup>
                        <TargetFrameworks>net9.0;net8.0</TargetFrameworks>
                    </PropertyGroup>
                    <ItemGroup>
                        <PackageReference Include="NuGet.Internal.Test.a" Version="1.0.0" />
                    </ItemGroup>
                </Project>
                """;
            var csprojPath = Path.Combine(testContext.SolutionRoot, "my.csproj");
            File.WriteAllText(csprojPath, csprojContents);

            // Act
            var result = _testFixture.RunDotnetExpectSuccess(
                workingDirectory: testContext.SolutionRoot,
                args: $"package update NuGet.Internal.Test.a",
                testOutputHelper: _testOutputHelper,
                environmentVariables: _envVars);

            // Assert
            result.ExitCode.Should().Be(0);

            string version = GetPackageReferenceVersion(csprojPath, "NuGet.Internal.Test.a");
            version.Should().Be("2.0.0");
        }

        [Fact]
        public async Task MultiTfmProjectWithConditionalPackageRef_PackageVersionUpdated()
        {
            // Arrange
            using var testContext = new SimpleTestPathContext();
            File.WriteAllText(testContext.NuGetConfig, string.Format(NugetConfigFormat, testContext.PackageSource));

            var a1 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "1.0.0");
            var a2 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "2.0.0");

            SimpleTestPackageContext[] packages = [a1, a2];
            await SimpleTestPackageUtility.CreatePackagesAsync(testContext.PackageSource, packages);

            var csprojContents = """
                <Project Sdk="Microsoft.NET.Sdk">
                    <PropertyGroup>
                        <TargetFrameworks>net9.0;net8.0</TargetFrameworks>
                    </PropertyGroup>
                    <ItemGroup>
                        <PackageReference Include="NuGet.Internal.Test.a" Version="1.0.0" Condition=" '$(TargetFramework)' == 'net8.0' " />
                    </ItemGroup>
                </Project>
                """;
            var csprojPath = Path.Combine(testContext.SolutionRoot, "my.csproj");
            File.WriteAllText(csprojPath, csprojContents);

            // Act
            var result = _testFixture.RunDotnetExpectSuccess(
                workingDirectory: testContext.SolutionRoot,
                args: $"package update NuGet.Internal.Test.a",
                testOutputHelper: _testOutputHelper,
                environmentVariables: _envVars);

            // Assert
            result.ExitCode.Should().Be(0);

            XDocument csproj = XDocument.Load(csprojPath);
            var packageReferenceA = csproj.XPathSelectElements("//PackageReference[@Include='NuGet.Internal.Test.a']").ToList();
            packageReferenceA.Count.Should().Be(1);
            packageReferenceA[0].Attribute("Version").Value.Should().Be("2.0.0");
            packageReferenceA[0].Attribute("Condition").Value.Should().Be(" '$(TargetFramework)' == 'net8.0' ");
        }

        [Fact]
        public async Task SingleTfmProject_CommitsRestore()
        {
            // Arrange
            using var testContext = new SimpleTestPathContext();
            File.WriteAllText(testContext.NuGetConfig, string.Format(NugetConfigFormat, testContext.PackageSource));

            var a1 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "1.0.0");
            var a2 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "2.0.0");

            SimpleTestPackageContext[] packages = [a1, a2];
            await SimpleTestPackageUtility.CreatePackagesAsync(testContext.PackageSource, packages);

            var csprojContents = """
                <Project Sdk="Microsoft.NET.Sdk">
                    <PropertyGroup>
                        <TargetFramework>net8.0</TargetFramework>
                    </PropertyGroup>
                    <ItemGroup>
                        <PackageReference Include="NuGet.Internal.Test.a" Version="1.0.0" />
                    </ItemGroup>
                </Project>
                """;
            var csprojPath = Path.Combine(testContext.SolutionRoot, "my.csproj");
            File.WriteAllText(csprojPath, csprojContents);

            // Act
            var result = _testFixture.RunDotnetExpectSuccess(
                workingDirectory: testContext.SolutionRoot,
                args: $"package update NuGet.Internal.Test.a",
                testOutputHelper: _testOutputHelper,
                environmentVariables: _envVars);

            // Assert
            result.ExitCode.Should().Be(0);

            string assetsFilePath = Path.Combine(testContext.SolutionRoot, "obj", "project.assets.json");
            LockFile assetsFile = new LockFileFormat().Read(assetsFilePath);
            assetsFile.Libraries[0].Name.Should().Be("NuGet.Internal.Test.a");
            assetsFile.Libraries[0].Version.Should().Be(new NuGetVersion("2.0.0"));
        }

        [Fact]
        public void InvalidProjectFile_OutputsMeaningfulError()
        {
            // Arrange
            using var testContext = new SimpleTestPathContext();

            var csprojContents = "<Invalid Xml";
            var csprojPath = Path.Combine(testContext.SolutionRoot, "my.csproj");
            File.WriteAllText(csprojPath, csprojContents);

            // Act
            var result = _testFixture.RunDotnetExpectFailure(
                workingDirectory: testContext.SolutionRoot,
                args: $"package update NuGet.Internal.Test.a",
                testOutputHelper: _testOutputHelper,
                environmentVariables: _envVars);

            // Assert
            result.Output.Should().Contain("MSB4025").And.Contain(csprojPath);
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public async Task SolutionWithTwoProjects_UpdateAll_UpdatesBothProjects(bool useSlnx)
        {
            // Arrange
            using var testContext = new SimpleTestPathContext();
            File.WriteAllText(testContext.NuGetConfig, string.Format(NugetConfigFormat, testContext.PackageSource));

            var a1 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "1.0.0");
            var a2 = new SimpleTestPackageContext("NuGet.Internal.Test.a", "2.0.0");

            SimpleTestPackageContext[] packages = [a1, a2];
            await SimpleTestPackageUtility.CreatePackagesAsync(testContext.PackageSource, packages);

            var solution = new SimpleTestSolutionContext(testContext.SolutionRoot, useSlnx);

            var project1 = SimpleTestProjectContext.CreateNETCore(
                "Project1",
                testContext.SolutionRoot,
                NuGetFramework.Parse("net9.0"));
            project1.AddPackageToAllFrameworks(a1);

            var project2 = SimpleTestProjectContext.CreateNETCore(
                "Project2",
                testContext.SolutionRoot,
                NuGetFramework.Parse("net9.0"));
            project2.AddPackageToAllFrameworks(a1);

            solution.Projects.Add(project1);
            solution.Projects.Add(project2);
            solution.Create();

            // Act
            var result = _testFixture.RunDotnetExpectSuccess(
                workingDirectory: testContext.SolutionRoot,
                args: $"package update",
                testOutputHelper: _testOutputHelper,
                environmentVariables: _envVars);

            // Assert
            result.ExitCode.Should().Be(0);

            string version1 = GetPackageReferenceVersion(project1.ProjectPath, "NuGet.Internal.Test.a");
            version1.Should().Be("2.0.0");

            string version2 = GetPackageReferenceVersion(project2.ProjectPath, "NuGet.Internal.Test.a");
            version2.Should().Be("2.0.0");
        }

        private string GetItemVersion(string projectPath, string itemType, string packageName)
        {
            var result = _testFixture.RunDotnetExpectSuccess(
                workingDirectory: Path.GetDirectoryName(projectPath),
                args: $"msbuild {Path.GetFileName(projectPath)} -getItem:{itemType}",
                testOutputHelper: _testOutputHelper,
                environmentVariables: _envVars);

            using JsonDocument document = JsonDocument.Parse(result.Output);
            JsonElement root = document.RootElement;

            if (root.TryGetProperty("Items", out JsonElement items) &&
                items.TryGetProperty(itemType, out JsonElement itemElements))
            {
                foreach (JsonElement item in itemElements.EnumerateArray())
                {
                    if (item.TryGetProperty("Identity", out JsonElement identity) &&
                        identity.GetString() == packageName)
                    {
                        if (item.TryGetProperty("Version", out JsonElement version))
                        {
                            return version.GetString();
                        }
                    }
                }
            }

            return null;
        }

        private string GetPackageReferenceVersion(string projectPath, string packageName)
        {
            return GetItemVersion(projectPath, "PackageReference", packageName);
        }

        private string GetPackageVersionVersion(string projectPath, string packageName)
        {
            return GetItemVersion(projectPath, "PackageVersion", packageName);
        }
    }
}