dependabot-nuget 0.311.0 → 0.313.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Run/RunWorkerTests.cs

@@ -16,8 +16,6 @@ using Xunit;
 
 namespace NuGetUpdater.Core.Test.Run;
 
-using static NuGetUpdater.Core.Utilities.EOLHandling;
-
 using TestFile = (string Path, string Content);
 using RawTestFile = (string Path, byte[] Content);
 
@@ -2777,6 +2775,162 @@ public class RunWorkerTests
         );
     }
 
+    [Fact]
+    public async Task AnalysisResultWithoutUpdatedDependenciesDoesNotCauseError()
+    {
+        await RunAsync(
+            job: new()
+            {
+                Source = new()
+                {
+                    Provider = "github",
+                    Repo = "test/repo",
+                },
+                Dependencies = [
+                    "Some.Package"
+                ],
+            },
+            files: [
+                ("project.csproj", "contents irrelevant")
+            ],
+            discoveryWorker: new TestDiscoveryWorker(_input =>
+            {
+                return Task.FromResult(new WorkspaceDiscoveryResult()
+                {
+                    Path = "",
+                    Projects = [
+                        new()
+                        {
+                            FilePath = "project.csproj",
+                            Dependencies = [
+                                new("Some.Package", "1.0.0", DependencyType.PackageReference)
+                            ],
+                            ImportedFiles = [],
+                            AdditionalFiles = [],
+                        }
+                    ]
+                });
+            }),
+            analyzeWorker: new TestAnalyzeWorker(_input =>
+            {
+                return Task.FromResult(new AnalysisResult()
+                {
+                    CanUpdate = true,
+                    UpdatedVersion = "1.1.0",
+                    UpdatedDependencies = [], // this is what was causing the problem
+                });
+            }),
+            updaterWorker: new TestUpdaterWorker(async input =>
+            {
+                var repoRootPath = input.Item1;
+                var filePath = input.Item2;
+                await File.WriteAllTextAsync(Path.Join(repoRootPath, filePath), "updated contents irrelevant");
+                return new UpdateOperationResult()
+                {
+                    UpdateOperations = [
+                        new DirectUpdate()
+                        {
+                            DependencyName = "Some.Package",
+                            NewVersion = NuGetVersion.Parse("1.1.0"),
+                            UpdatedFiles = ["project.csproj"]
+                        }
+                    ]
+                };
+            }),
+            expectedResult: new()
+            {
+                Base64DependencyFiles = [
+                    new()
+                    {
+                        Directory = "/",
+                        Name = "project.csproj",
+                        Content = Convert.ToBase64String(Encoding.UTF8.GetBytes("contents irrelevant")),
+                        ContentEncoding = "base64"
+                    }
+                ],
+                BaseCommitSha = "TEST-COMMIT-SHA",
+            },
+            expectedApiMessages: [
+                new UpdatedDependencyList()
+                {
+                    Dependencies = [
+                        new()
+                        {
+                            Name = "Some.Package",
+                            Version = "1.0.0",
+                            Requirements = [
+                                new()
+                                {
+                                    Requirement = "1.0.0",
+                                    File = "/project.csproj",
+                                    Groups = ["dependencies"],
+                                }
+                            ]
+                        }
+                    ],
+                    DependencyFiles = ["/project.csproj"]
+                },
+                new IncrementMetric()
+                {
+                    Metric = "updater.started",
+                    Tags = new()
+                    {
+                        ["operation"] = "group_update_all_versions"
+                    }
+                },
+                new CreatePullRequest()
+                {
+                    Dependencies =
+                    [
+                        new ReportedDependency()
+                        {
+                            Name = "Some.Package",
+                            Version = "1.1.0",
+                            Requirements =
+                            [
+                                new ReportedRequirement()
+                                {
+                                    Requirement = "1.1.0",
+                                    File = "/project.csproj",
+                                    Groups = ["dependencies"],
+                                    Source = new()
+                                    {
+                                        SourceUrl = null,
+                                        Type = "nuget_repo",
+                                    }
+                                }
+                            ],
+                            PreviousVersion = "1.0.0",
+                            PreviousRequirements =
+                            [
+                                new ReportedRequirement()
+                                {
+                                    Requirement = "1.0.0",
+                                    File = "/project.csproj",
+                                    Groups = ["dependencies"],
+                                }
+                            ],
+                        }
+                    ],
+                    UpdatedDependencyFiles =
+                    [
+                        new DependencyFile()
+                        {
+                            Name = "project.csproj",
+                            Directory = "/",
+                            Content = "updated contents irrelevant",
+                        },
+                    ],
+                    BaseCommitSha = "TEST-COMMIT-SHA",
+                    CommitMessage = TestPullRequestCommitMessage,
+                    PrTitle = TestPullRequestTitle,
+                    PrBody = TestPullRequestBody,
+                },
+                new MarkAsProcessed("TEST-COMMIT-SHA"),
+            ]
+        );
+    }
+
     [Fact]
     public async Task ByteOrderMarksAreDetectedAndRestored()
     {
@@ -3266,6 +3420,50 @@ public class RunWorkerTests
         );
     }
 
+    [Fact]
+    public async Task UnknownErrorsGenerateAllRequiredApiCalls()
+    {
+        await RunAsync(
+            job: new Job()
+            {
+                Source = new()
+                {
+                    Provider = "github",
+                    Repo = "test/repo",
+                    Directory = "some-dir",
+                }
+            },
+            packages: [],
+            files: [],
+            discoveryWorker: new TestDiscoveryWorker(_input =>
+            {
+                throw new FileNotFoundException("some required file is missing");
+            }),
+            analyzeWorker: TestAnalyzeWorker.FromResults(), // unreachable
+            updaterWorker: TestUpdaterWorker.FromResults(), // unreachable
+            expectedResult: new RunResult()
+            {
+                Base64DependencyFiles = [],
+                BaseCommitSha = "TEST-COMMIT-SHA",
+            },
+            expectedApiMessages:
+            [
+                new UnknownError(new FileNotFoundException("some required file is missing"), "TEST-JOB-ID"), // from record_update_job_error
+                new UnknownError(new FileNotFoundException("some required file is missing"), "TEST-JOB-ID"), // from record_update_job_unknown_error
+                new IncrementMetric()
+                {
+                    Metric = "updater.update_job_unknown_error",
+                    Tags = new()
+                    {
+                        ["package_manager"] = "nuget",
+                        ["class_name"] = "FileNotFoundException"
+                    }
+                },
+                new MarkAsProcessed("TEST-COMMIT-SHA")
+            ]
+        );
+    }
+
     internal static Task RunAsync(Job job, TestFile[] files, IDiscoveryWorker? discoveryWorker, IAnalyzeWorker? analyzeWorker, IUpdaterWorker? updaterWorker, RunResult expectedResult, object[] expectedApiMessages, MockNuGetPackage[]? packages = null, ExperimentsManager? experimentsManager = null, string? repoContentsPath = null)
     {
         var rawTestFiles = files.Select(f => (f.Path, Encoding.UTF8.GetBytes(f.Content))).ToArray();
@@ -3300,13 +3498,36 @@ public class RunWorkerTests
         var actualResult = await worker.RunAsync(job, repoContentsPathDirectoryInfo, "TEST-COMMIT-SHA");
         var actualApiMessages = testApiHandler.ReceivedMessages
             .Select(m =>
-                m.Object switch
+            {
+                object newObject;
+                switch (m.Object)
                 {
                     // this isn't the place to verify the generated text
-                    CreatePullRequest create => (m.Type, create with { CommitMessage = TestPullRequestCommitMessage, PrTitle = TestPullRequestTitle, PrBody = TestPullRequestBody }),
-                    UpdatePullRequest update => (m.Type, update with { CommitMessage = TestPullRequestCommitMessage, PrTitle = TestPullRequestTitle, PrBody = TestPullRequestBody }),
-                    _ => m,
+                    case CreatePullRequest create:
+                        newObject = create with { CommitMessage = TestPullRequestCommitMessage, PrTitle = TestPullRequestTitle, PrBody = TestPullRequestBody };
+                        break;
+                    case UpdatePullRequest update:
+                        newObject = update with { CommitMessage = TestPullRequestCommitMessage, PrTitle = TestPullRequestTitle, PrBody = TestPullRequestBody };
+                        break;
+                    // don't test callstacks
+                    case UnknownError unknown:
+                        var message = (string)unknown.Details["error-message"];
+                        var stackTraceOffset = message.IndexOf('\n');
+                        if (stackTraceOffset >= 0)
+                        {
+                            var messageWithoutStackTrace = message[..stackTraceOffset].TrimEnd('\r');
+                            unknown.Details["error-message"] = messageWithoutStackTrace;
+                        }
+
+                        newObject = unknown;
+                        break;
+                    default:
+                        newObject = m.Object;
+                        break;
                 }
+
+                return (m.Type, Object: newObject);
+            }
             ).ToArray();
 
         // assert

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Run/SerializationTests.cs

@@ -8,7 +8,7 @@ using Xunit;
 
 namespace NuGetUpdater.Core.Test.Run;
 
-public class SerializationTests
+public class SerializationTests : TestBase
 {
     [Fact]
     public void DeserializeJob()
@@ -260,15 +260,9 @@ public class SerializationTests
     }
 
     [Theory]
-    [MemberData(nameof(DeserializeErrorTypesData))]
+    [MemberData(nameof(SerializeErrorTypesData))]
     public void SerializeError(JobErrorBase error, string expectedSerialization)
     {
-        if (error is UnknownError unknown)
-        {
-            // special case the exception's call stack to make it testable
-            unknown.Details["error-backtrace"] = "TEST-BACKTRACE";
-        }
-
         var actual = HttpApiHandler.Serialize(error);
         Assert.Equal(expectedSerialization, actual);
     }
@@ -279,7 +273,7 @@ public class SerializationTests
         var untestedTypes = typeof(JobErrorBase).Assembly.GetTypes()
             .Where(t => t.IsSubclassOf(typeof(JobErrorBase)))
             .ToHashSet();
-        foreach (object?[] data in DeserializeErrorTypesData())
+        foreach (object?[] data in SerializeErrorTypesData())
         {
             var testedErrorType = data[0]!.GetType();
             untestedTypes.Remove(testedErrorType);
@@ -601,7 +595,42 @@ public class SerializationTests
         Assert.Equal(expected, actual);
     }
 
-    public static IEnumerable<object?[]> DeserializeErrorTypesData()
+    [Fact]
+    public void SerializeRealUnknownErrorWithInnerException()
+    {
+        // arrange
+        using var tempDir = new TemporaryDirectory();
+        var action = new Action(() =>
+        {
+            try
+            {
+                throw new NotImplementedException("inner message");
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException("outer message", ex);
+            }
+        });
+        var ex = Assert.Throws<InvalidOperationException>(action);
+
+        // act
+        var error = JobErrorBase.ErrorFromException(ex, "TEST-JOB-ID", tempDir.DirectoryPath);
+
+        // assert
+        // real exception message should look like this:
+        // System.InvalidOperationException: outer message
+        //  ---> System.NotImplementedException: inner message
+        //    at Namespace.Class.Method() in file.cs:line 123
+        //    --- End of inner exception stack trace ---
+        //    at Namespace.Class.Method() in file.cs:line 456
+        var errorMessage = Assert.IsType<string>(error.Details["error-message"]);
+        var lines = errorMessage.Split('\n').Select(l => l.TrimEnd('\r')).ToArray();
+        Assert.Equal("System.InvalidOperationException: outer message", lines[0]);
+        Assert.Equal(" ---> System.NotImplementedException: inner message", lines[1]);
+        Assert.Contains("   --- End of inner exception stack trace ---", lines[2..]);
+    }
+
+    public static IEnumerable<object?[]> SerializeErrorTypesData()
     {
         yield return
         [
@@ -679,7 +708,7 @@ public class SerializationTests
         [
             new UnknownError(new Exception("some message"), "JOB-ID"),
             """
-            {"data":{"error-type":"unknown_error","error-details":{"error-class":"Exception","error-message":"some message","error-backtrace":"TEST-BACKTRACE","package-manager":"nuget","job-id":"JOB-ID"}}}
+            {"data":{"error-type":"unknown_error","error-details":{"error-class":"Exception","error-message":"System.Exception: some message","error-backtrace":"","package-manager":"nuget","job-id":"JOB-ID"}}}
             """
         ];
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Run/TestApiHandler.cs

@@ -1,5 +1,4 @@
 using NuGetUpdater.Core.Run;
-using NuGetUpdater.Core.Run.ApiModel;
 
 namespace NuGetUpdater.Core.Test;
 
@@ -9,45 +8,9 @@ internal class TestApiHandler : IApiHandler
 
     public IEnumerable<(Type Type, object Object)> ReceivedMessages => _receivedMessages;
 
-    public Task RecordUpdateJobError(JobErrorBase error)
+    public Task SendAsync(string endpoint, object body, string method)
     {
-        _receivedMessages.Add((error.GetType(), error));
-        return Task.CompletedTask;
-    }
-
-    public Task UpdateDependencyList(UpdatedDependencyList updatedDependencyList)
-    {
-        _receivedMessages.Add((updatedDependencyList.GetType(), updatedDependencyList));
-        return Task.CompletedTask;
-    }
-
-    public Task IncrementMetric(IncrementMetric incrementMetric)
-    {
-        _receivedMessages.Add((incrementMetric.GetType(), incrementMetric));
-        return Task.CompletedTask;
-    }
-
-    public Task CreatePullRequest(CreatePullRequest createPullRequest)
-    {
-        _receivedMessages.Add((createPullRequest.GetType(), createPullRequest));
-        return Task.CompletedTask;
-    }
-
-    public Task ClosePullRequest(ClosePullRequest closePullRequest)
-    {
-        _receivedMessages.Add((closePullRequest.GetType(), closePullRequest));
-        return Task.CompletedTask;
-    }
-
-    public Task UpdatePullRequest(UpdatePullRequest updatePullRequest)
-    {
-        _receivedMessages.Add((updatePullRequest.GetType(), updatePullRequest));
-        return Task.CompletedTask;
-    }
-
-    public Task MarkAsProcessed(MarkAsProcessed markAsProcessed)
-    {
-        _receivedMessages.Add((markAsProcessed.GetType(), markAsProcessed));
+        _receivedMessages.Add((body.GetType(), body));
         return Task.CompletedTask;
     }
 }

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

@@ -10,13 +10,13 @@ namespace NuGetUpdater.Core.Test
 {
     public class TestHttpServer : IDisposable
     {
-        private readonly Func<string, string, (int, byte[])> _requestHandler;
+        private readonly Func<string, string, (int, byte[]?)> _requestHandler;
         private readonly HttpListener _listener;
         private bool _runServer = true;
 
         public string BaseUrl { get; }
 
-        private TestHttpServer(string baseurl, Func<string, string, (int, byte[])> requestHandler)
+        private TestHttpServer(string baseurl, Func<string, string, (int, byte[]?)> requestHandler)
         {
             BaseUrl = baseurl;
             _requestHandler = requestHandler;
@@ -45,7 +45,11 @@ namespace NuGetUpdater.Core.Test
                 var context = await _listener.GetContextAsync();
                 var (statusCode, response) = _requestHandler(context.Request.HttpMethod, context.Request.Url!.AbsoluteUri);
                 context.Response.StatusCode = statusCode;
-                await context.Response.OutputStream.WriteAsync(response);
+                if (response is not null)
+                {
+                    await context.Response.OutputStream.WriteAsync(response);
+                }
+
                 context.Response.Close();
             }
         }
@@ -57,7 +61,7 @@ namespace NuGetUpdater.Core.Test
             return CreateTestServer((method, url) => requestHandler(url));
         }
 
-        public static TestHttpServer CreateTestServer(Func<string, string, (int, byte[])> requestHandler)
+        public static TestHttpServer CreateTestServer(Func<string, string, (int, byte[]?)> requestHandler)
         {
             // static lock to ensure the port is not recycled after `FindFreePort()` and before we can start the real server
             lock (PortGate)
@@ -77,7 +81,7 @@ namespace NuGetUpdater.Core.Test
 
         public static TestHttpServer CreateTestStringServer(Func<string, string, (int, string)> requestHandler)
         {
-            Func<string, string, (int, byte[])> bytesRequestHandler = (method, url) =>
+            Func<string, string, (int, byte[]?)> bytesRequestHandler = (method, url) =>
             {
                 var (statusCode, response) = requestHandler(method, url);
                 return (statusCode, Encoding.UTF8.GetBytes(response));

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

@@ -55,7 +55,7 @@ public class PackageReferenceUpdaterTests
 
         // assert
         await buildFile.SaveAsync();
-        var actualContents = await File.ReadAllTextAsync(fullProjectPath);
+        var actualContents = await File.ReadAllTextAsync(fullProjectPath, TestContext.Current.CancellationToken);
         var expectedContents = """
             <Project Sdk="Microsoft.NET.Sdk">
               <PropertyGroup>
@@ -71,6 +71,104 @@ public class PackageReferenceUpdaterTests
         Assert.Equal(expectedContents, actualContents);
     }
 
+    [Fact]
+    public async Task DirectBuildFileChangesAreMaintainedWhenPinningTransitiveDependency_DirectoryPackagesPropsIsDiscovered()
+    {
+        // arrange
+        using var tempDir = await TemporaryDirectory.CreateWithContentsAsync(
+        [
+            ("project.csproj", """
+                 <Project Sdk="Microsoft.NET.Sdk">
+                   <PropertyGroup>
+                     <TargetFramework>net9.0</TargetFramework>
+                   </PropertyGroup>
+                   <ItemGroup>
+                     <PackageReference Include="Completely.Different.Package" />
+                     <PackageReference Include="Some.Package" />
+                   </ItemGroup>
+                 </Project>
+                 """),
+            ("Directory.Packages.props", """
+                <Project>
+                  <PropertyGroup>
+                    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+                  </PropertyGroup>
+                  <ItemGroup>
+                    <PackageVersion Include="Completely.Different.Package" Version="1.0.0" />
+                    <PackageVersion Include="Some.Package" Version="1.0.0" />
+                  </ItemGroup>
+                </Project>
+                """)
+        ]);
+        var packages = new[]
+        {
+             MockNuGetPackage.CreateSimplePackage("Completely.Different.Package", "1.0.0", "net9.0"),
+             MockNuGetPackage.CreateSimplePackage("Completely.Different.Package", "2.0.0", "net9.0"),
+             MockNuGetPackage.CreateSimplePackage("Some.Package", "1.0.0", "net9.0", [(null, [("Transitive.Package", "1.0.0")])]),
+             MockNuGetPackage.CreateSimplePackage("Transitive.Package", "1.0.0", "net9.0"),
+             MockNuGetPackage.CreateSimplePackage("Transitive.Package", "2.0.0", "net9.0"),
+         };
+        await UpdateWorkerTestBase.MockNuGetPackagesInDirectory(packages, tempDir.DirectoryPath);
+        var fullProjectPath = Path.Combine(tempDir.DirectoryPath, "project.csproj");
+        var fullDirectoryPackagesPath = Path.Combine(tempDir.DirectoryPath, "Directory.Packages.props");
+        var buildFiles = new[]
+        {
+            ProjectBuildFile.Open(tempDir.DirectoryPath, fullProjectPath),
+            ProjectBuildFile.Open(tempDir.DirectoryPath, fullDirectoryPackagesPath)
+        }.ToImmutableArray();
+        var experimentsManager = new ExperimentsManager();
+
+        // act
+        // pin transitive dependency
+        var updatedFiles = await PackageReferenceUpdater.UpdateTransitiveDependencyAsync(
+            tempDir.DirectoryPath,
+            fullProjectPath,
+            "Transitive.Package",
+            "2.0.0",
+            buildFiles,
+            experimentsManager,
+            new TestLogger());
+
+        // subsequent update should not overwrite previous change
+        PackageReferenceUpdater.TryUpdateDependencyVersion(buildFiles, "Completely.Different.Package", "1.0.0", "2.0.0", new TestLogger());
+
+        // assert
+        foreach (var bf in buildFiles)
+        {
+            await bf.SaveAsync();
+        }
+
+        var actualProjectContents = await File.ReadAllTextAsync(fullProjectPath, TestContext.Current.CancellationToken);
+        var expectedProjectContents = """
+             <Project Sdk="Microsoft.NET.Sdk">
+               <PropertyGroup>
+                 <TargetFramework>net9.0</TargetFramework>
+               </PropertyGroup>
+               <ItemGroup>
+                 <PackageReference Include="Completely.Different.Package" />
+                 <PackageReference Include="Some.Package" />
+                 <PackageReference Include="Transitive.Package" />
+               </ItemGroup>
+             </Project>
+             """;
+        Assert.Equal(expectedProjectContents.Replace("\r", ""), actualProjectContents.Replace("\r", ""));
+
+        var actualDirectoryPackagesContents = await File.ReadAllTextAsync(fullDirectoryPackagesPath, TestContext.Current.CancellationToken);
+        var expectedDirectoryPackagesContents = """
+            <Project>
+              <PropertyGroup>
+                <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+              </PropertyGroup>
+              <ItemGroup>
+                <PackageVersion Include="Completely.Different.Package" Version="2.0.0" />
+                <PackageVersion Include="Some.Package" Version="1.0.0" />
+                <PackageVersion Include="Transitive.Package" Version="2.0.0" />
+              </ItemGroup>
+            </Project>
+            """;
+        Assert.Equal(expectedDirectoryPackagesContents.Replace("\r", ""), actualDirectoryPackagesContents.Replace("\r", ""));
+    }
+
     [Theory]
     [MemberData(nameof(ComputeUpdateOperationsTestData))]
     public async Task ComputeUpdateOperations

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/MSBuildHelperTests.cs

@@ -1852,6 +1852,22 @@ public class MSBuildHelperTests : TestBase
             // expectedError
             new UpdateNotPossible(["Some.Package.1.2.3"]),
         ];
+
+        yield return
+        [
+            // output
+            "Failed to fetch results from V2 feed at 'http://nuget.example.com/FindPackagesById()?id='Some.Package'&semVerLevel=2.0.0' with following message : Response status code does not indicate success: 404.",
+            // expectedError
+            new DependencyNotFound("Some.Package"),
+        ];
+
+        yield return
+        [
+            // output
+            "This part is not reported.\nAn error occurred while reading file '/path/to/packages.config': Some error message.\nThis part is not reported.",
+            // expectedError
+            new DependencyFileNotParseable("/path/to/packages.config", "Some error message."),
+        ];
     }
 
     public static IEnumerable<object[]> GetTopLevelPackageDependencyInfosTestData()