dependabot-nuget 0.283.0 → 0.285.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/BindingRedirectManager.cs

@@ -28,7 +28,9 @@ internal static class BindingRedirectManager
     ///      https://learn.microsoft.com/en-us/nuget/resources/check-project-format
     /// </remarks>
     /// <param name="projectBuildFile">The project build file (*.xproj) to be updated</param>
-    public static async ValueTask UpdateBindingRedirectsAsync(ProjectBuildFile projectBuildFile)
+    /// <param name="updatedPackageName"/>The name of the package that was updated</param>
+    /// <param name="updatedPackageVersion">The version of the package that was updated</param>
+    public static async ValueTask UpdateBindingRedirectsAsync(ProjectBuildFile projectBuildFile, string updatedPackageName, string updatedPackageVersion)
     {
         var configFile = await TryGetRuntimeConfigurationFile(projectBuildFile);
         if (configFile is null)
@@ -47,7 +49,20 @@ internal static class BindingRedirectManager
             return;
         }
 
-        var fileContent = AddBindingRedirects(configFile, bindings);
+        // we need to detect what assembly references come from the newly updated package; the `HintPath` will look like
+        //    ..\packages\Some.Package.1.2.3\lib\net45\Some.Package.dll
+        // so we first pull out the packages sub-path, e.g., `..\packages`
+        // then we add the updated package name, version, and a trailing directory separator and ensure it's a unix-style path
+        //    e.g., ../packages/Some.Package/1.2.3/
+        // at this point any assembly in that directory is from the updated package and will need a binding redirect
+        // finally we pull out the assembly `HintPath` values for _all_ references relative to the project file in a unix-style value
+        //    e.g., ../packages/Some.Other.Package/4.5.6/lib/net45/Some.Other.Package.dll
+        // all of that is passed to `AddBindingRedirects()` so we can ensure binding redirects for the relevant assemblies
+        var packagesDirectory = PackagesConfigUpdater.GetPathToPackagesDirectory(projectBuildFile, updatedPackageName, updatedPackageVersion, packagesConfigPath: null)!;
+        var assemblyPathPrefix = Path.Combine(packagesDirectory, $"{updatedPackageName}.{updatedPackageVersion}").NormalizePathToUnix().EnsureSuffix("/");
+        var assemblyPaths = references.Select(static x => x.HintPath).Select(x => Path.GetRelativePath(Path.GetDirectoryName(projectBuildFile.Path)!, x).NormalizePathToUnix()).ToList();
+        var bindingsAndAssemblyPaths = bindings.Zip(assemblyPaths);
+        var fileContent = AddBindingRedirects(configFile, bindingsAndAssemblyPaths, assemblyPathPrefix);
         configFile = configFile with { Content = fileContent };
 
         await File.WriteAllTextAsync(configFile.Path, configFile.Content);
@@ -161,10 +176,10 @@ internal static class BindingRedirectManager
         }
     }
 
-    private static string AddBindingRedirects(ConfigurationFile configFile, IEnumerable<Runtime_AssemblyBinding> bindingRedirects)
+    private static string AddBindingRedirects(ConfigurationFile configFile, IEnumerable<(Runtime_AssemblyBinding Binding, string AssemblyPath)> bindingRedirectsAndAssemblyPaths, string assemblyPathPrefix)
     {
         // Do nothing if there are no binding redirects to add, bail out
-        if (!bindingRedirects.Any())
+        if (!bindingRedirectsAndAssemblyPaths.Any())
         {
             return configFile.Content;
         }
@@ -185,7 +200,7 @@ internal static class BindingRedirectManager
         // Get all of the current bindings in config
         var currentBindings = GetAssemblyBindings(runtime);
 
-        foreach (var bindingRedirect in bindingRedirects)
+        foreach (var (bindingRedirect, assemblyPath) in bindingRedirectsAndAssemblyPaths)
         {
             // If the binding redirect already exists in config, update it. Otherwise, add it.
             var bindingAssemblyIdentity = new AssemblyIdentity(bindingRedirect.Name, bindingRedirect.PublicKeyToken);
@@ -208,11 +223,17 @@ internal static class BindingRedirectManager
             }
             else
             {
-                // Get an assembly binding element to use
-                var assemblyBindingElement = GetAssemblyBindingElement(runtime);
+                // only add a previously missing binding redirect if it's related to the package that caused the whole update
+                // this isn't strictly necessary, but can be helpful to the end user and it's easy for them to revert if they
+                // don't like this particular change
+                if (assemblyPath.StartsWith(assemblyPathPrefix, StringComparison.OrdinalIgnoreCase))
+                {
+                    // Get an assembly binding element to use
+                    var assemblyBindingElement = GetAssemblyBindingElement(runtime);
 
-                // Add the binding to that element
-                assemblyBindingElement.AddIndented(bindingRedirect.ToXElement());
+                    // Add the binding to that element
+                    assemblyBindingElement.AddIndented(bindingRedirect.ToXElement());
+                }
             }
         }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/PackagesConfigUpdater.cs

@@ -93,7 +93,7 @@ internal static class PackagesConfigUpdater
         projectBuildFile.NormalizeDirectorySeparatorsInProject();
 
         // Update binding redirects
-        await BindingRedirectManager.UpdateBindingRedirectsAsync(projectBuildFile);
+        await BindingRedirectManager.UpdateBindingRedirectsAsync(projectBuildFile, dependencyName, newDependencyVersion);
 
         logger.Log("    Writing project file back to disk");
         await projectBuildFile.SaveAsync();
@@ -196,7 +196,7 @@ internal static class PackagesConfigUpdater
         return processes;
     }
 
-    internal static string? GetPathToPackagesDirectory(ProjectBuildFile projectBuildFile, string dependencyName, string dependencyVersion, string packagesConfigPath)
+    internal static string? GetPathToPackagesDirectory(ProjectBuildFile projectBuildFile, string dependencyName, string dependencyVersion, string? packagesConfigPath)
     {
         // the packages directory can be found from the hint path of the matching dependency, e.g., when given "Newtonsoft.Json", "7.0.1", and a project like this:
         // <Project>
@@ -242,7 +242,7 @@ internal static class PackagesConfigUpdater
             }
         }
 
-        if (partialPathMatch is null)
+        if (partialPathMatch is null && packagesConfigPath is not null)
         {
             // if we got this far, we couldn't find the packages directory for the specified dependency and there are 2 possibilities:
             // 1. the dependency doesn't actually exist in this project

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

@@ -27,6 +27,8 @@ internal static class PathHelper
 
     public static string EnsurePrefix(this string s, string prefix) => s.StartsWith(prefix) ? s : prefix + s;
 
+    public static string EnsureSuffix(this string s, string suffix) => s.EndsWith(suffix) ? s : s + suffix;
+
     public static string NormalizePathToUnix(this string path) => path.Replace("\\", "/");
 
     public static string NormalizeUnixPathParts(this string path)

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Clone/CloneWorkerTests.cs

@@ -0,0 +1,183 @@
+using NuGetUpdater.Core.Clone;
+using NuGetUpdater.Core.Run.ApiModel;
+using NuGetUpdater.Core.Test.Run;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Clone;
+
+public class CloneWorkerTests
+{
+    private const string TestRepoPath = "TEST/REPO/PATH";
+
+    [Fact]
+    public void CloneCommandsAreGenerated()
+    {
+        TestCommands(
+            provider: "github",
+            repoMoniker: "test/repo",
+            expectedCommands:
+            [
+                (["clone", "--no-tags", "--depth", "1", "--recurse-submodules", "--shallow-submodules", "https://github.com/test/repo", TestRepoPath], null)
+            ]
+        );
+    }
+
+    [Fact]
+    public void CloneCommandsAreGeneratedWhenBranchIsSpecified()
+    {
+        TestCommands(
+            provider: "github",
+            repoMoniker: "test/repo",
+            branch: "some-branch",
+            expectedCommands:
+            [
+                (["clone", "--no-tags", "--depth", "1", "--recurse-submodules", "--shallow-submodules", "--branch", "some-branch", "--single-branch", "https://github.com/test/repo", TestRepoPath], null)
+            ]
+        );
+    }
+
+    [Fact]
+    public void CloneCommandsAreGeneratedWhenCommitIsSpecified()
+    {
+        TestCommands(
+            provider: "github",
+            repoMoniker: "test/repo",
+            commit: "abc123",
+            expectedCommands:
+            [
+                (["clone", "--no-tags", "--depth", "1", "--recurse-submodules", "--shallow-submodules", "https://github.com/test/repo", TestRepoPath], null),
+                (["fetch", "--depth", "1", "--recurse-submodules=on-demand", "origin", "abc123"], TestRepoPath),
+                (["reset", "--hard", "--recurse-submodules", "abc123"], TestRepoPath)
+            ]
+        );
+    }
+
+    [Fact]
+    public async Task SuccessfulCloneGeneratesNoApiMessages()
+    {
+        await TestCloneAsync(
+            provider: "github",
+            repoMoniker: "test/repo",
+            expectedApiMessages: []
+        );
+    }
+
+    [Fact]
+    public async Task UnauthorizedCloneGeneratesTheExpectedApiMessagesFromGenericOutput()
+    {
+        await TestCloneAsync(
+            provider: "github",
+            repoMoniker: "test/repo",
+            testGitCommandHandler: new TestGitCommandHandlerWithOutputs("Authentication failed for repo", ""),
+            expectedApiMessages:
+            [
+                new JobRepoNotFound("Authentication failed for repo"),
+                new MarkAsProcessed("unknown"),
+            ],
+            expectedExitCode: 1
+        );
+    }
+
+    [Fact]
+    public async Task UnauthorizedCloneGeneratesTheExpectedApiMessagesFromGitCommandOutput()
+    {
+        await TestCloneAsync(
+            provider: "github",
+            repoMoniker: "test/repo",
+            testGitCommandHandler: new TestGitCommandHandlerWithOutputs("", "fatal: could not read Username for 'https://github.com': No such device or address"),
+            expectedApiMessages:
+            [
+                new JobRepoNotFound("fatal: could not read Username for 'https://github.com': No such device or address"),
+                new MarkAsProcessed("unknown"),
+            ],
+            expectedExitCode: 1
+        );
+    }
+
+    private class TestGitCommandHandlerWithOutputs : TestGitCommandHandler
+    {
+        private readonly string _stdout;
+        private readonly string _stderr;
+
+        public TestGitCommandHandlerWithOutputs(string stdout, string stderr)
+        {
+            _stdout = stdout;
+            _stderr = stderr;
+        }
+
+        public override async Task RunGitCommandAsync(IReadOnlyCollection<string> args, string? workingDirectory = null)
+        {
+            await base.RunGitCommandAsync(args, workingDirectory);
+            ShellGitCommandHandler.HandleErrorsFromOutput(_stdout, _stderr);
+        }
+    }
+
+    private static void TestCommands(string provider, string repoMoniker, (string[] Args, string? WorkingDirectory)[] expectedCommands, string? branch = null, string? commit = null)
+    {
+        var job = new Job()
+        {
+            Source = new()
+            {
+                Provider = provider,
+                Repo = repoMoniker,
+                Branch = branch,
+                Commit = commit,
+            }
+        };
+        var actualCommands = CloneWorker.GetAllCommandArgs(job, TestRepoPath);
+        VerifyCommands(expectedCommands, actualCommands);
+    }
+
+    private static async Task TestCloneAsync(string provider, string repoMoniker, object[] expectedApiMessages, string? branch = null, string? commit = null, TestGitCommandHandler? testGitCommandHandler = null, int expectedExitCode = 0)
+    {
+        // arrange
+        var testApiHandler = new TestApiHandler();
+        testGitCommandHandler ??= new TestGitCommandHandler();
+        var testLogger = new TestLogger();
+        var worker = new CloneWorker(testApiHandler, testGitCommandHandler, testLogger);
+
+        // act
+        var job = new Job()
+        {
+            Source = new()
+            {
+                Provider = provider,
+                Repo = repoMoniker,
+                Branch = branch,
+                Commit = commit,
+            }
+        };
+        var exitCode = await worker.RunAsync(job, TestRepoPath);
+
+        // assert
+        Assert.Equal(expectedExitCode, exitCode);
+
+        var actualApiMessages = testApiHandler.ReceivedMessages.ToArray();
+        if (actualApiMessages.Length > expectedApiMessages.Length)
+        {
+            var extraApiMessages = actualApiMessages.Skip(expectedApiMessages.Length).Select(m => RunWorkerTests.SerializeObjectAndType(m.Object)).ToArray();
+            Assert.Fail($"Expected {expectedApiMessages.Length} API messages, but got {extraApiMessages.Length} extra:\n\t{string.Join("\n\t", extraApiMessages)}");
+        }
+        if (expectedApiMessages.Length > actualApiMessages.Length)
+        {
+            var missingApiMessages = expectedApiMessages.Skip(actualApiMessages.Length).Select(m => RunWorkerTests.SerializeObjectAndType(m)).ToArray();
+            Assert.Fail($"Expected {expectedApiMessages.Length} API messages, but only got {actualApiMessages.Length}; missing:\n\t{string.Join("\n\t", missingApiMessages)}");
+        }
+    }
+
+    private static void VerifyCommands((string[] Args, string? WorkingDirectory)[] expected, (string[] Args, string? WorkingDirectory)[] actual)
+    {
+        var expectedCommands = StringifyCommands(expected);
+        var actualCommands = StringifyCommands(actual);
+        Assert.True(expectedCommands.Length == actualCommands.Length, $"Expected {expectedCommands.Length} messages:\n\t{string.Join("\n\t", expectedCommands)}\ngot {actualCommands.Length}:\n\t{string.Join("\n\t", actualCommands)}");
+        foreach (var (expectedCommand, actualCommand) in expectedCommands.Zip(actualCommands))
+        {
+            Assert.Equal(expectedCommand, actualCommand);
+        }
+    }
+
+    private static string[] StringifyCommands((string[] Args, string? WorkingDirectory)[] commandArgs) => commandArgs.Select(a => StringifyCommand(a.Args, a.WorkingDirectory)).ToArray();
+    private static string StringifyCommand(string[] args, string? workingDirectory) => $"args=[{string.Join(", ", args)}], workingDirectory={ReplaceWorkingDirectory(workingDirectory)}";
+    private static string ReplaceWorkingDirectory(string? arg) => arg ?? "NULL";
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Clone/TestGitCommandHandler.cs

@@ -0,0 +1,16 @@
+using NuGetUpdater.Core.Clone;
+
+namespace NuGetUpdater.Core.Test.Clone;
+
+internal class TestGitCommandHandler : IGitCommandHandler
+{
+    private readonly List<(string[] Args, string? WorkingDirectory)> _seenCommands = new();
+
+    public IReadOnlyCollection<(string[] Args, string? WorkingDirectory)> SeenCommands => _seenCommands;
+
+    public virtual Task RunGitCommandAsync(IReadOnlyCollection<string> args, string? workingDirectory = null)
+    {
+        _seenCommands.Add((args.ToArray(), workingDirectory));
+        return Task.CompletedTask;
+    }
+}