dependabot-nuget 0.311.0 → 0.313.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Analyze/VersionFinderTests.cs

@@ -1,9 +1,12 @@
 using System.Collections.Immutable;
+using System.Text.Json;
 
 using NuGet.Frameworks;
 using NuGet.Versioning;
 
 using NuGetUpdater.Core.Analyze;
+using NuGetUpdater.Core.Run;
+using NuGetUpdater.Core.Run.ApiModel;
 using NuGetUpdater.Core.Test.Update;
 using NuGetUpdater.Core.Test.Utilities;
 
@@ -11,7 +14,7 @@ using Xunit;
 
 namespace NuGetUpdater.Core.Test.Analyze;
 
-public class VersionFinderTests
+public class VersionFinderTests : TestBase
 {
     [Fact]
     public void VersionFilter_VersionInIgnoredVersions_ReturnsFalse()
@@ -223,4 +226,74 @@ public class VersionFinderTests
         var expected = new[] { "2.0.0" };
         AssertEx.Equal(expected, actual);
     }
+
+    [Fact]
+    public async Task FeedReturnsBadJson()
+    {
+        // arrange
+        using var http = TestHttpServer.CreateTestStringServer(url =>
+        {
+            var uri = new Uri(url, UriKind.Absolute);
+            var baseUrl = $"{uri.Scheme}://{uri.Host}:{uri.Port}";
+            return uri.PathAndQuery switch
+            {
+                // initial and search query are good, update should be possible...
+                "/index.json" => (200, $$"""
+                    {
+                        "version": "3.0.0",
+                        "resources": [
+                            {
+                                "@id": "{{baseUrl}}/download",
+                                "@type": "PackageBaseAddress/3.0.0"
+                            },
+                            {
+                                "@id": "{{baseUrl}}/query",
+                                "@type": "SearchQueryService"
+                            },
+                            {
+                                "@id": "{{baseUrl}}/registrations",
+                                "@type": "RegistrationsBaseUrl"
+                            }
+                        ]
+                    }
+                    """),
+                _ => (200, "") // empty string instead of expected JSON object
+            };
+        });
+        var feedUrl = $"{http.BaseUrl.TrimEnd('/')}/index.json";
+        using var tempDir = await TemporaryDirectory.CreateWithContentsAsync(
+            ("NuGet.Config", $"""
+                <configuration>
+                  <packageSources>
+                    <clear />
+                    <add key="private_feed" value="{feedUrl}" allowInsecureConnections="true" />
+                  </packageSources>
+                </configuration>
+                """)
+        );
+
+        // act
+        var tfm = NuGetFramework.Parse("net9.0");
+        var dependencyInfo = new DependencyInfo
+        {
+            Name = "Some.Dependency",
+            Version = "1.0.0",
+            IsVulnerable = false,
+            IgnoredVersions = [],
+            Vulnerabilities = [],
+        };
+        var logger = new TestLogger();
+        var nugetContext = new NuGetContext(tempDir.DirectoryPath);
+        var exception = await Assert.ThrowsAsync<BadResponseException>(async () =>
+        {
+            await VersionFinder.GetVersionsAsync([tfm], dependencyInfo, nugetContext, logger, CancellationToken.None);
+        });
+        var error = JobErrorBase.ErrorFromException(exception, "TEST-JOB-ID", tempDir.DirectoryPath);
+
+        // assert
+        var expected = new PrivateSourceBadResponse([feedUrl]);
+        var expectedJson = JsonSerializer.Serialize(expected, RunWorker.SerializerOptions);
+        var actualJson = JsonSerializer.Serialize(error, RunWorker.SerializerOptions);
+        Assert.Equal(expectedJson, actualJson);
+    }
 }

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

@@ -111,7 +111,7 @@ public class CloneWorkerTests
 
         // assert
         Assert.Equal(1, result);
-        var expectedParseErrorObject = testApiHandler.ReceivedMessages.Single(m => m.Type == typeof(UnknownError));
+        var expectedParseErrorObject = testApiHandler.ReceivedMessages.First(m => m.Type == typeof(UnknownError));
         var unknownError = (UnknownError)expectedParseErrorObject.Object;
         Assert.Equal("JsonException", unknownError.Details["error-class"]);
     }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Discover/DiscoveryWorkerTests.Project.cs

@@ -832,10 +832,8 @@ public partial class DiscoveryWorkerTests
                         {
                             FilePath = "myproj.csproj",
                             Dependencies = [
-                                new("Some.Package", "1.2.3.4", DependencyType.PackageReference, TargetFrameworks: ["net7.0"], IsDirect: true),
-                                new("Some.Package", "1.2.3.4", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
-                                new("Transitive.Dependency", "5.6.7.8", DependencyType.Unknown, TargetFrameworks: ["net7.0"], IsTransitive: true),
-                                new("Transitive.Dependency", "5.6.7.8", DependencyType.Unknown, TargetFrameworks: ["net8.0"], IsTransitive: true),
+                                new("Some.Package", "1.2.3.4", DependencyType.PackageReference, TargetFrameworks: ["net7.0", "net8.0"], IsDirect: true),
+                                new("Transitive.Dependency", "5.6.7.8", DependencyType.Unknown, TargetFrameworks: ["net7.0", "net8.0"], IsTransitive: true),
                             ],
                             Properties = [
                                 new("TargetFrameworks", "net7.0;net8.0", "myproj.csproj"),
@@ -1191,11 +1189,7 @@ public partial class DiscoveryWorkerTests
                         {
                             FilePath = "project.csproj",
                             Dependencies = [
-                                new("Some.Package", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0-android"], IsDirect: true),
-                                new("Some.Package", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0-ios"], IsDirect: true),
-                                new("Some.Package", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0-maccatalyst"], IsDirect: true),
-                                new("Some.Package", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0-macos"], IsDirect: true),
-                                new("Some.Package", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0-windows"], IsDirect: true),
+                                new("Some.Package", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0-android", "net8.0-ios", "net8.0-maccatalyst", "net8.0-macos", "net8.0-windows"], IsDirect: true),
                             ],
                             Properties = [
                                 new("TargetFrameworks", "net8.0-ios;net8.0-android;net8.0-macos;net8.0-maccatalyst;net8.0-windows", @"src/project.csproj"),

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Discover/DiscoveryWorkerTests.cs

@@ -673,8 +673,7 @@ public partial class DiscoveryWorkerTests : DiscoveryWorkerTestBase
                         FilePath = "src/project.csproj",
                         TargetFrameworks = ["net7.0", "net8.0"],
                         Dependencies = [
-                            new("Some.Package", "9.0.1", DependencyType.PackageReference, TargetFrameworks: ["net7.0"], IsDirect: true),
-                            new("Some.Package", "9.0.1", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
+                            new("Some.Package", "9.0.1", DependencyType.PackageReference, TargetFrameworks: ["net7.0", "net8.0"], IsDirect: true),
                         ],
                         Properties = [
                             new("TargetFrameworks", "net7.0;net8.0", "src/project.csproj")

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Discover/SdkProjectDiscoveryTests.cs

@@ -1,4 +1,5 @@
 using System.Collections.Immutable;
+using System.Text;
 
 using NuGetUpdater.Core.Discover;
 using NuGetUpdater.Core.Test.Update;
@@ -297,8 +298,7 @@ public class SdkProjectDiscoveryTests : DiscoveryWorkerTestBase
                     FilePath = "library.csproj",
                     Dependencies =
                     [
-                        new("Some.Dependency", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net7.0"], IsDirect: true),
-                        new("Some.Dependency", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
+                        new("Some.Dependency", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net7.0", "net8.0"], IsDirect: true),
                     ],
                     ImportedFiles = [],
                     Properties =
@@ -524,6 +524,62 @@ public class SdkProjectDiscoveryTests : DiscoveryWorkerTestBase
         );
     }
 
+    [Fact]
+    public async Task TransitiveDependenciesWithoutAssembliesAreReported()
+    {
+        await TestDiscoverAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Dependency", "1.2.3", "net9.0", [(null, [("Transitive.Dependency", "4.5.6")])]),
+                new MockNuGetPackage(
+                    "Transitive.Dependency",
+                    "4.5.6",
+                    Files: [
+                        ("build/Transitive.Dependency.targets", Encoding.UTF8.GetBytes("<Project />"))
+                    ],
+                    DependencyGroups: [(null, [("Super.Transitive.Dependency", "7.8.9")])]
+                ),
+                MockNuGetPackage.CreateSimplePackage("Super.Transitive.Dependency", "7.8.9", "net9.0"),
+            ],
+            startingDirectory: "src",
+            projectPath: "src/library.csproj",
+            files:
+            [
+                ("src/library.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net9.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Some.Dependency" Version="1.2.3" />
+                      </ItemGroup>
+                    </Project>
+                    """)
+            ],
+            expectedProjects:
+            [
+                new()
+                {
+                    FilePath = "library.csproj",
+                    Dependencies =
+                    [
+                        new("Some.Dependency", "1.2.3", DependencyType.PackageReference, TargetFrameworks: ["net9.0"], IsDirect: true),
+                        new("Transitive.Dependency", "4.5.6", DependencyType.Unknown, TargetFrameworks: ["net9.0"], IsTransitive: true),
+                        new("Super.Transitive.Dependency", "7.8.9", DependencyType.Unknown, TargetFrameworks: ["net9.0"], IsTransitive: true),
+                    ],
+                    ImportedFiles = [],
+                    Properties =
+                    [
+                        new("TargetFramework", "net9.0", "src/library.csproj"),
+                    ],
+                    TargetFrameworks = ["net9.0"],
+                    ReferencedProjectPaths = [],
+                    AdditionalFiles = [],
+                },
+            ]
+        );
+    }
+
     private static async Task TestDiscoverAsync(string startingDirectory, string projectPath, TestFile[] files, ImmutableArray<ExpectedSdkProjectDiscoveryResult> expectedProjects, MockNuGetPackage[]? packages = null)
     {
         using var testDirectory = await TemporaryDirectory.CreateWithContentsAsync(files);

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

@@ -0,0 +1,157 @@
+using NuGetUpdater.Core.Run;
+using NuGetUpdater.Core.Run.ApiModel;
+using NuGetUpdater.Core.Test.Utilities;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Run;
+
+public class HttpApiHandlerTests
+{
+    [Fact]
+    public async Task FailedRequestWithContentReportsData()
+    {
+        // arrange
+        // this mimics an error that can be returned by the server
+        var errorContent = """{"errors":[{"status":400,"title":"Bad Request","detail":"some-detail"}]}""";
+        using var http = TestHttpServer.CreateTestStringServer((method, url) =>
+        {
+            return (400, errorContent);
+        });
+        var handler = new HttpApiHandler(http.BaseUrl, "TEST-ID");
+
+        // act
+        var exception = await Assert.ThrowsAsync<HttpRequestException>(() => handler.IncrementMetric(new()
+        {
+            // body is irrelevant for this test
+            Metric = "TEST",
+        }));
+
+        // assert
+        var expectedMessage = $"400 (BadRequest): {errorContent}";
+        Assert.Equal(expectedMessage, exception.Message);
+    }
+
+    [Fact]
+    public async Task FailedRequestWithNoContentOnlyReportsStatusCode()
+    {
+        // arrange
+        using var http = TestHttpServer.CreateTestServer((method, url) =>
+        {
+            // no error content returned
+            return (400, null);
+        });
+        var handler = new HttpApiHandler(http.BaseUrl, "TEST-ID");
+
+        // act
+        var exception = await Assert.ThrowsAsync<HttpRequestException>(() => handler.IncrementMetric(new()
+        {
+            // body is irrelevant for this test
+            Metric = "TEST",
+        }));
+
+        // assert
+        var expectedMessage = $"400 (BadRequest)";
+        Assert.Equal(expectedMessage, exception.Message);
+    }
+
+    [Fact]
+    public async Task ApiCallsAreAutomaticallyRetriedWhenTheServerThrowsAnError()
+    {
+        // arrange
+        var requestCount = 0;
+        using var http = TestHttpServer.CreateTestServer((method, url) =>
+        {
+            if (requestCount < 2)
+            {
+                requestCount++;
+                return (500, Array.Empty<byte>());
+            }
+
+            return (200, Array.Empty<byte>());
+        });
+        var handler = new HttpApiHandler(http.BaseUrl, "TEST-ID");
+
+        // act
+        await handler.IncrementMetric(new()
+        {
+            Metric = "test",
+        });
+    }
+
+    [Fact]
+    public async Task ApiCallsAreNotRetriedOnABadRequest()
+    {
+        // arrange
+        var requestCount = 0;
+        using var http = TestHttpServer.CreateTestServer((method, url) =>
+        {
+            requestCount++;
+            return (400, Array.Empty<byte>());
+        });
+        var handler = new HttpApiHandler(http.BaseUrl, "TEST-ID");
+
+        // act
+        await Assert.ThrowsAsync<HttpRequestException>(() => handler.IncrementMetric(new() { Metric = "test" }));
+        Assert.True(requestCount == 1, $"Expected only 1 request, but received {requestCount}.");
+    }
+
+    [Theory]
+    [MemberData(nameof(ErrorsAreSentToTheCorrectEndpointTestData))]
+    public async Task ErrorsAreSentToTheCorrectEndpoint(JobErrorBase error, params string[] expectedEndpoints)
+    {
+        // arrange
+        var actualEndpoints = new List<string>();
+        using var http = TestHttpServer.CreateTestStringServer((method, url) =>
+        {
+            var expectedPrefix = "/update_jobs/TEST-ID/";
+            var actualPathAndQuery = new Uri(url).PathAndQuery;
+            if (!actualPathAndQuery.StartsWith(expectedPrefix))
+            {
+                throw new Exception($"Didn't find expected prefix: [{expectedPrefix}]");
+            }
+
+            actualEndpoints.Add(actualPathAndQuery[expectedPrefix.Length..]);
+            return (200, "ok");
+        });
+        var handler = new HttpApiHandler(http.BaseUrl, "TEST-ID");
+
+        // act
+        await handler.RecordUpdateJobError(error);
+
+        // assert
+        AssertEx.Equal(expectedEndpoints, actualEndpoints);
+    }
+
+    [Fact]
+    public void ErrorsAreSentToTheCorrectEndpoint_AllTypesAreTested()
+    {
+        var remainingErrorTypes = typeof(JobErrorBase).Assembly
+            .GetTypes()
+            .Where(t => t.IsSubclassOf(typeof(JobErrorBase)))
+            .Select(t => t.Name)
+            .ToHashSet();
+        foreach (var testData in ErrorsAreSentToTheCorrectEndpointTestData())
+        {
+            var seenErrorType = testData[0].GetType().Name;
+            remainingErrorTypes.Remove(seenErrorType);
+        }
+
+        Assert.Empty(remainingErrorTypes);
+    }
+
+    public static IEnumerable<object[]> ErrorsAreSentToTheCorrectEndpointTestData()
+    {
+        yield return [new BadRequirement("unused"), "record_update_job_error"];
+        yield return [new DependencyFileNotFound("unused"), "record_update_job_error"];
+        yield return [new DependencyFileNotParseable("unused"), "record_update_job_error"];
+        yield return [new DependencyNotFound("unused"), "record_update_job_error"];
+        yield return [new JobRepoNotFound("unused"), "record_update_job_error"];
+        yield return [new PrivateSourceAuthenticationFailure(["unused"]), "record_update_job_error"];
+        yield return [new PrivateSourceBadResponse(["unused"]), "record_update_job_error"];
+        yield return [new PullRequestExistsForLatestVersion("unused", "unused"), "record_update_job_error"];
+        yield return [new SecurityUpdateNotNeeded("unused"), "record_update_job_error"];
+        yield return [new UnknownError(new Exception("unused"), "unused"), "record_update_job_error", "record_update_job_unknown_error", "increment_metric"];
+        yield return [new UpdateNotPossible(["unused"]), "record_update_job_error"];
+    }
+}

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

@@ -0,0 +1,86 @@
+using System.Net;
+using System.Text.Json;
+
+using NuGet.Protocol.Core.Types;
+
+using NuGetUpdater.Core.Run;
+using NuGetUpdater.Core.Run.ApiModel;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Run;
+
+public class JobErrorBaseTests : TestBase
+{
+    [Theory]
+    [MemberData(nameof(GenerateErrorFromExceptionTestData))]
+    public async Task GenerateErrorFromException(Exception exception, JobErrorBase expectedError)
+    {
+        // arrange
+        // some error types require a NuGet.Config file to be present
+        using var tempDir = await TemporaryDirectory.CreateWithContentsAsync(
+            ("NuGet.Config", """
+                <configuration>
+                  <packageSources>
+                    <clear />
+                    <add key="some_package_feed" value="http://nuget.example.com/v3/index.json" allowInsecureConnections="true" />
+                  </packageSources>
+                </configuration>
+                """)
+        );
+
+        // act
+        var actualError = JobErrorBase.ErrorFromException(exception, "TEST-JOB-ID", tempDir.DirectoryPath);
+
+        // assert
+        var actualErrorJson = JsonSerializer.Serialize(actualError, RunWorker.SerializerOptions);
+        var expectedErrorJson = JsonSerializer.Serialize(expectedError, RunWorker.SerializerOptions);
+        Assert.Equal(expectedErrorJson, actualErrorJson);
+    }
+
+    public static IEnumerable<object[]> GenerateErrorFromExceptionTestData()
+    {
+        // internal error from package feed
+        yield return
+        [
+            new HttpRequestException("nope", null, HttpStatusCode.InternalServerError),
+            new PrivateSourceBadResponse(["http://nuget.example.com/v3/index.json"]),
+        ];
+
+        // inner exception turns into private_source_bad_response; 500
+        yield return
+        [
+            new FatalProtocolException("nope", new HttpRequestException("nope", null, HttpStatusCode.InternalServerError)),
+            new PrivateSourceBadResponse(["http://nuget.example.com/v3/index.json"]),
+        ];
+
+        // inner exception turns into private_source_bad_response; ResponseEnded
+        yield return
+        [
+            new FatalProtocolException("nope", new HttpRequestException("nope", new HttpIOException(HttpRequestError.ResponseEnded))),
+            new PrivateSourceBadResponse(["http://nuget.example.com/v3/index.json"]),
+        ];
+
+        // top-level exception turns into private_source_authentication_failure
+        yield return
+        [
+            new HttpRequestException("nope", null, HttpStatusCode.Unauthorized),
+            new PrivateSourceAuthenticationFailure(["http://nuget.example.com/v3/index.json"]),
+        ];
+
+        // inner exception turns into private_source_authentication_failure
+        yield return
+        [
+            // the NuGet libraries commonly do this
+            new FatalProtocolException("nope", new HttpRequestException("nope", null, HttpStatusCode.Unauthorized)),
+            new PrivateSourceAuthenticationFailure(["http://nuget.example.com/v3/index.json"]),
+        ];
+
+        // unknown errors all the way down; report the initial top-level error
+        yield return
+        [
+            new Exception("outer", new Exception("inner")),
+            new UnknownError(new Exception("outer", new Exception("inner")), "TEST-JOB-ID"),
+        ];
+    }
+}

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

@@ -190,8 +190,7 @@ public class MessageReportTests
             """
             Error type: unknown_error
             - error-class: NotImplementedException
-            - error-message: error message
-            - error-backtrace: <unknown>
+            - error-message: System.NotImplementedException: error message
             - package-manager: nuget
             - job-id: TEST-JOB-ID
             """