dependabot-nuget 0.311.0 → 0.312.0

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,116 @@
+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 (500, 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 = $"500 (InternalServerError)";
+        Assert.Equal(expectedMessage, exception.Message);
+    }
+
+    [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/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
             """

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