dependabot-nuget 0.291.0 → 0.293.0

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation.Test/RuntimePackagesTests.cs

@@ -0,0 +1,206 @@
+using Semver;
+
+using Xunit;
+
+namespace DotNetPackageCorrelation;
+
+public class RuntimePackagesTests
+{
+    [Theory]
+    [MemberData(nameof(CorrelatedPackageCanBeFoundData))]
+    public void CorrelatedPackageCanBeFound(RuntimePackages runtimePackages, string runtimePackageName, string runtimePackageVersion, string candidatePackageName, string? expectedPackageVersion)
+    {
+        var packageMapper = PackageMapper.Load(runtimePackages);
+        var actualPackageVersion = packageMapper.GetPackageVersionThatShippedWithOtherPackage(runtimePackageName, SemVersion.Parse(runtimePackageVersion), candidatePackageName);
+        if (expectedPackageVersion is null)
+        {
+            Assert.Null(actualPackageVersion);
+        }
+        else
+        {
+            Assert.NotNull(actualPackageVersion);
+            Assert.Equal(expectedPackageVersion, actualPackageVersion.ToString());
+        }
+    }
+
+    public static IEnumerable<object?[]> CorrelatedPackageCanBeFoundData()
+    {
+        // package not found in specified runtime, but it is in earlier runtime; more recent runtime has that package, but that's not returned
+        yield return
+        [
+            // runtimePackages
+            new RuntimePackages()
+            {
+                Runtimes = new SortedDictionary<SemVersion, PackageSet>(SemVerComparer.Instance)
+                {
+                    {
+                        SemVersion.Parse("1.0.100"),
+                        new PackageSet()
+                        {
+                            Packages = new SortedDictionary<string, SemVersion>(StringComparer.OrdinalIgnoreCase)
+                            {
+                                { "Runtime.Package", SemVersion.Parse("1.0.0") },
+                                { "Some.Package", SemVersion.Parse("1.0.1") }
+                            }
+                        }
+                    },
+                    {
+                        SemVersion.Parse("1.0.101"),
+                        new PackageSet()
+                        {
+                            Packages = new SortedDictionary<string, SemVersion>(StringComparer.OrdinalIgnoreCase)
+                            {
+                                // this runtime didn't ship with a new version of "Some.Package", but the earlier release did
+                                { "Runtime.Package", SemVersion.Parse("1.0.1") }
+                            }
+                        }
+                    },
+                    {
+                        SemVersion.Parse("1.0.200"),
+                        new PackageSet()
+                        {
+                            Packages = new SortedDictionary<string, SemVersion>(StringComparer.OrdinalIgnoreCase)
+                            {
+                                // the requested package shipped with this runtime, but this runtime isn't the correct version so it's not returned
+                                { "Runtime.Package", SemVersion.Parse("1.0.2") },
+                                { "Some.Package", SemVersion.Parse("1.0.2") }
+                            }
+                        }
+                    },
+                }
+            },
+            // runtimePackageName
+            "Runtime.Package",
+            // runtimePackageVersion
+            "1.0.1",
+            // candidatePackageName
+            "Some.Package",
+            // expectedPackageVersion
+            "1.0.1"
+        ];
+
+        // package differing in case is found
+        yield return
+        [
+            // runtimePackages
+            new RuntimePackages()
+            {
+                Runtimes = new SortedDictionary<SemVersion, PackageSet>(SemVerComparer.Instance)
+                {
+                    {
+                        SemVersion.Parse("1.0.100"),
+                        new PackageSet()
+                        {
+                            Packages = new SortedDictionary<string, SemVersion>(StringComparer.OrdinalIgnoreCase)
+                            {
+                                { "runtime.package", SemVersion.Parse("1.0.0") },
+                                { "some.package", SemVersion.Parse("1.0.1") }
+                            }
+                        }
+                    }
+                }
+            },
+            // runtimePackageName
+            "Runtime.Package",
+            // runtimePackageVersion
+            "1.0.0",
+            // candidatePackageName
+            "Some.Package",
+            // expectedPackageVersion
+            "1.0.1"
+        ];
+
+        // runtime package not found by name
+        yield return
+        [
+            // runtimePackages
+            new RuntimePackages()
+            {
+                Runtimes = new SortedDictionary<SemVersion, PackageSet>(SemVerComparer.Instance)
+                {
+                    {
+                        SemVersion.Parse("1.0.100"),
+                        new PackageSet()
+                        {
+                            Packages = new SortedDictionary<string, SemVersion>(StringComparer.OrdinalIgnoreCase)
+                            {
+                                { "runtime.package", SemVersion.Parse("1.0.0") },
+                                { "some.package", SemVersion.Parse("1.0.1") }
+                            }
+                        }
+                    }
+                }
+            },
+            // runtimePackageName
+            "Different.Runtime.Package",
+            // runtimePackageVersion
+            "1.0.0",
+            // candidatePackageName
+            "Some.Package",
+            // expectedPackageVersion
+            null
+        ];
+
+        // runtime package not found by version
+        yield return
+        [
+            // runtimePackages
+            new RuntimePackages()
+            {
+                Runtimes = new SortedDictionary<SemVersion, PackageSet>(SemVerComparer.Instance)
+                {
+                    {
+                        SemVersion.Parse("1.0.100"),
+                        new PackageSet()
+                        {
+                            Packages = new SortedDictionary<string, SemVersion>(StringComparer.OrdinalIgnoreCase)
+                            {
+                                { "runtime.package", SemVersion.Parse("1.0.0") },
+                                { "some.package", SemVersion.Parse("1.0.1") }
+                            }
+                        }
+                    }
+                }
+            },
+            // runtimePackageName
+            "Runtime.Package",
+            // runtimePackageVersion
+            "9.9.9",
+            // candidatePackageName
+            "Some.Package",
+            // expectedPackageVersion
+            null
+        ];
+
+        // candidate package not found
+        yield return
+        [
+            // runtimePackages
+            new RuntimePackages()
+            {
+                Runtimes = new SortedDictionary<SemVersion, PackageSet>(SemVerComparer.Instance)
+                {
+                    {
+                        SemVersion.Parse("1.0.100"),
+                        new PackageSet()
+                        {
+                            Packages = new SortedDictionary<string, SemVersion>(StringComparer.OrdinalIgnoreCase)
+                            {
+                                { "runtime.package", SemVersion.Parse("1.0.0") },
+                                { "some.package", SemVersion.Parse("1.0.1") }
+                            }
+                        }
+                    }
+                }
+            },
+            // runtimePackageName
+            "Runtime.Package",
+            // runtimePackageVersion
+            "1.0.0",
+            // candidatePackageName
+            "Package.Not.In.This.Runtime",
+            // expectedPackageVersion
+            null
+        ];
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli/Commands/AnalyzeCommand.cs

@@ -7,6 +7,7 @@ namespace NuGetUpdater.Cli.Commands;
 
 internal static class AnalyzeCommand
 {
+    internal static readonly Option<string> JobIdOption = new("--job-id") { IsRequired = true };
     internal static readonly Option<FileInfo> JobPathOption = new("--job-path") { IsRequired = true };
     internal static readonly Option<DirectoryInfo> RepoRootOption = new("--repo-root") { IsRequired = true };
     internal static readonly Option<FileInfo> DependencyFilePathOption = new("--dependency-file-path") { IsRequired = true };
@@ -17,6 +18,7 @@ internal static class AnalyzeCommand
     {
         Command command = new("analyze", "Determines how to update a dependency based on the workspace discovery information.")
         {
+            JobIdOption,
             JobPathOption,
             RepoRootOption,
             DependencyFilePathOption,
@@ -26,13 +28,13 @@ internal static class AnalyzeCommand
 
         command.TreatUnmatchedTokensAsErrors = true;
 
-        command.SetHandler(async (jobPath, repoRoot, discoveryPath, dependencyPath, analysisDirectory) =>
+        command.SetHandler(async (jobId, jobPath, repoRoot, discoveryPath, dependencyPath, analysisDirectory) =>
         {
             var logger = new ConsoleLogger();
-            var experimentsManager = await ExperimentsManager.FromJobFileAsync(jobPath.FullName, logger);
-            var worker = new AnalyzeWorker(experimentsManager, logger);
+            var (experimentsManager, _errorResult) = await ExperimentsManager.FromJobFileAsync(jobId, jobPath.FullName);
+            var worker = new AnalyzeWorker(jobId, experimentsManager, logger);
             await worker.RunAsync(repoRoot.FullName, discoveryPath.FullName, dependencyPath.FullName, analysisDirectory.FullName);
-        }, JobPathOption, RepoRootOption, DiscoveryFilePathOption, DependencyFilePathOption, AnalysisFolderOption);
+        }, JobIdOption, JobPathOption, RepoRootOption, DiscoveryFilePathOption, DependencyFilePathOption, AnalysisFolderOption);
 
         return command;
     }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli/Commands/CloneCommand.cs

@@ -30,7 +30,7 @@ internal static class CloneCommand
             var apiHandler = new HttpApiHandler(apiUrl.ToString(), jobId);
             var logger = new ConsoleLogger();
             var gitCommandHandler = new ShellGitCommandHandler(logger);
-            var worker = new CloneWorker(apiHandler, gitCommandHandler, logger);
+            var worker = new CloneWorker(jobId, apiHandler, gitCommandHandler);
             var exitCode = await worker.RunAsync(jobPath, repoContentsPath);
             setExitCode(exitCode);
         }, JobPathOption, RepoContentsPathOption, ApiUrlOption, JobIdOption);

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli/Commands/DiscoverCommand.cs

@@ -7,6 +7,7 @@ namespace NuGetUpdater.Cli.Commands;
 
 internal static class DiscoverCommand
 {
+    internal static readonly Option<string> JobIdOption = new("--job-id") { IsRequired = true };
     internal static readonly Option<FileInfo> JobPathOption = new("--job-path") { IsRequired = true };
     internal static readonly Option<DirectoryInfo> RepoRootOption = new("--repo-root") { IsRequired = true };
     internal static readonly Option<string> WorkspaceOption = new("--workspace") { IsRequired = true };
@@ -16,6 +17,7 @@ internal static class DiscoverCommand
     {
         Command command = new("discover", "Generates a report of the workspace dependencies and where they are located.")
         {
+            JobIdOption,
             JobPathOption,
             RepoRootOption,
             WorkspaceOption,
@@ -24,13 +26,26 @@ internal static class DiscoverCommand
 
         command.TreatUnmatchedTokensAsErrors = true;
 
-        command.SetHandler(async (jobPath, repoRoot, workspace, outputPath) =>
+        command.SetHandler(async (jobId, jobPath, repoRoot, workspace, outputPath) =>
         {
+            var (experimentsManager, error) = await ExperimentsManager.FromJobFileAsync(jobId, jobPath.FullName);
+            if (error is not null)
+            {
+                // to make testing easier, this should be a `WorkspaceDiscoveryResult` object
+                var discoveryErrorResult = new WorkspaceDiscoveryResult
+                {
+                    Error = error,
+                    Path = workspace,
+                    Projects = [],
+                };
+                await DiscoveryWorker.WriteResultsAsync(repoRoot.FullName, outputPath.FullName, discoveryErrorResult);
+                return;
+            }
+
             var logger = new ConsoleLogger();
-            var experimentsManager = await ExperimentsManager.FromJobFileAsync(jobPath.FullName, logger);
-            var worker = new DiscoveryWorker(experimentsManager, logger);
+            var worker = new DiscoveryWorker(jobId, experimentsManager, logger);
             await worker.RunAsync(repoRoot.FullName, workspace, outputPath.FullName);
-        }, JobPathOption, RepoRootOption, WorkspaceOption, OutputOption);
+        }, JobIdOption, JobPathOption, RepoRootOption, WorkspaceOption, OutputOption);
 
         return command;
     }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli/Commands/RunCommand.cs

@@ -33,12 +33,12 @@ internal static class RunCommand
         command.SetHandler(async (jobPath, repoContentsPath, apiUrl, jobId, outputPath, baseCommitSha) =>
         {
             var apiHandler = new HttpApiHandler(apiUrl.ToString(), jobId);
+            var (experimentsManager, _errorResult) = await ExperimentsManager.FromJobFileAsync(jobId, jobPath.FullName);
             var logger = new ConsoleLogger();
-            var experimentsManager = await ExperimentsManager.FromJobFileAsync(jobPath.FullName, logger);
-            var discoverWorker = new DiscoveryWorker(experimentsManager, logger);
-            var analyzeWorker = new AnalyzeWorker(experimentsManager, logger);
-            var updateWorker = new UpdaterWorker(experimentsManager, logger);
-            var worker = new RunWorker(apiHandler, discoverWorker, analyzeWorker, updateWorker, logger);
+            var discoverWorker = new DiscoveryWorker(jobId, experimentsManager, logger);
+            var analyzeWorker = new AnalyzeWorker(jobId, experimentsManager, logger);
+            var updateWorker = new UpdaterWorker(jobId, experimentsManager, logger);
+            var worker = new RunWorker(jobId, apiHandler, discoverWorker, analyzeWorker, updateWorker, logger);
             await worker.RunAsync(jobPath, repoContentsPath, baseCommitSha, outputPath);
         }, JobPathOption, RepoContentsPathOption, ApiUrlOption, JobIdOption, OutputPathOption, BaseCommitShaOption);
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli/Commands/UpdateCommand.cs

@@ -6,6 +6,7 @@ namespace NuGetUpdater.Cli.Commands;
 
 internal static class UpdateCommand
 {
+    internal static readonly Option<string> JobIdOption = new("--job-id") { IsRequired = true };
     internal static readonly Option<FileInfo> JobPathOption = new("--job-path") { IsRequired = true };
     internal static readonly Option<DirectoryInfo> RepoRootOption = new("--repo-root", () => new DirectoryInfo(Environment.CurrentDirectory)) { IsRequired = false };
     internal static readonly Option<FileInfo> SolutionOrProjectFileOption = new("--solution-or-project") { IsRequired = true };
@@ -19,6 +20,7 @@ internal static class UpdateCommand
     {
         Command command = new("update", "Applies the changes from an analysis report to update a dependency.")
         {
+            JobIdOption,
             JobPathOption,
             RepoRootOption,
             SolutionOrProjectFileOption,
@@ -30,15 +32,25 @@ internal static class UpdateCommand
         };
 
         command.TreatUnmatchedTokensAsErrors = true;
-
-        command.SetHandler(async (jobPath, repoRoot, solutionOrProjectFile, dependencyName, newVersion, previousVersion, isTransitive, resultOutputPath) =>
+        command.SetHandler(async (context) =>
         {
+            // since we have more than 8 arguments, we have to pull them out manually
+            var jobId = context.ParseResult.GetValueForOption(JobIdOption)!;
+            var jobPath = context.ParseResult.GetValueForOption(JobPathOption)!;
+            var repoRoot = context.ParseResult.GetValueForOption(RepoRootOption)!;
+            var solutionOrProjectFile = context.ParseResult.GetValueForOption(SolutionOrProjectFileOption)!;
+            var dependencyName = context.ParseResult.GetValueForOption(DependencyNameOption)!;
+            var newVersion = context.ParseResult.GetValueForOption(NewVersionOption)!;
+            var previousVersion = context.ParseResult.GetValueForOption(PreviousVersionOption)!;
+            var isTransitive = context.ParseResult.GetValueForOption(IsTransitiveOption);
+            var resultOutputPath = context.ParseResult.GetValueForOption(ResultOutputPathOption);
+
+            var (experimentsManager, _error) = await ExperimentsManager.FromJobFileAsync(jobId, jobPath.FullName);
             var logger = new ConsoleLogger();
-            var experimentsManager = await ExperimentsManager.FromJobFileAsync(jobPath.FullName, logger);
-            var worker = new UpdaterWorker(experimentsManager, logger);
+            var worker = new UpdaterWorker(jobId, experimentsManager, logger);
             await worker.RunAsync(repoRoot.FullName, solutionOrProjectFile.FullName, dependencyName, previousVersion, newVersion, isTransitive, resultOutputPath);
             setExitCode(0);
-        }, JobPathOption, RepoRootOption, SolutionOrProjectFileOption, DependencyNameOption, NewVersionOption, PreviousVersionOption, IsTransitiveOption, ResultOutputPathOption);
+        });
 
         return command;
     }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli.Test/EntryPointTests.Analyze.cs

@@ -26,6 +26,8 @@ public partial class EntryPointTests
             await RunAsync(path =>
                 [
                     "analyze",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     Path.Combine(path, "job.json"),
                     "--repo-root",
@@ -146,6 +148,8 @@ public partial class EntryPointTests
             await RunAsync(path =>
                 [
                     "analyze",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     Path.Combine(path, "job.json"),
                     "--repo-root",
@@ -235,6 +239,8 @@ public partial class EntryPointTests
             await RunAsync(path =>
                 [
                     "analyze",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     Path.Combine(path, "job.json"),
                     "--repo-root",
@@ -345,7 +351,8 @@ public partial class EntryPointTests
                     {
                         if (args[i] == "--job-path")
                         {
-                            experimentsManager = await ExperimentsManager.FromJobFileAsync(args[i + 1], new TestLogger());
+                            var experimentsResult = await ExperimentsManager.FromJobFileAsync("TEST-JOB-ID", args[i + 1]);
+                            experimentsManager = experimentsResult.ExperimentsManager;
                         }
                     }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli.Test/EntryPointTests.Discover.cs

@@ -1,5 +1,6 @@
 using System.Text;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 
 using NuGetUpdater.Core;
 using NuGetUpdater.Core.Discover;
@@ -25,6 +26,8 @@ public partial class EntryPointTests
             await RunAsync(path =>
                 [
                     "discover",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     Path.Combine(path, "job.json"),
                     "--repo-root",
@@ -83,6 +86,8 @@ public partial class EntryPointTests
             await RunAsync(path =>
                 [
                     "discover",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     Path.Combine(path, "job.json"),
                     "--repo-root",
@@ -178,6 +183,8 @@ public partial class EntryPointTests
             await RunAsync(path =>
                 [
                     "discover",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     Path.Combine(path, "job.json"),
                     "--repo-root",
@@ -251,6 +258,8 @@ public partial class EntryPointTests
             await RunAsync(path =>
                 [
                     "discover",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     Path.Combine(path, "job.json"),
                     "--repo-root",
@@ -321,6 +330,8 @@ public partial class EntryPointTests
             await RunAsync(path =>
                 [
                     "discover",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     Path.Combine(path, "job.json"),
                     "--repo-root",
@@ -388,6 +399,85 @@ public partial class EntryPointTests
             );
         }
 
+        [Fact]
+        public async Task JobFileParseErrorIsReported_InvalidJson()
+        {
+            using var testDirectory = new TemporaryDirectory();
+            var jobFilePath = Path.Combine(testDirectory.DirectoryPath, "job.json");
+            var resultFilePath = Path.Combine(testDirectory.DirectoryPath, DiscoveryWorker.DiscoveryResultFileName);
+            await File.WriteAllTextAsync(jobFilePath, "not json");
+            await RunAsync(path =>
+                [
+                    "discover",
+                    "--job-id",
+                    "TEST-JOB-ID",
+                    "--job-path",
+                    jobFilePath,
+                    "--repo-root",
+                    path,
+                    "--workspace",
+                    "/",
+                    "--output",
+                    resultFilePath
+                ],
+                initialFiles: [],
+                expectedResult: new()
+                {
+                    Path = "/",
+                    Projects = [],
+                    ErrorRegex = "Error deserializing job file contents",
+                }
+            );
+        }
+
+        [Fact]
+        public async Task JobFileParseErrorIsReported_BadRequirement()
+        {
+            using var testDirectory = new TemporaryDirectory();
+            var jobFilePath = Path.Combine(testDirectory.DirectoryPath, "job.json");
+            var resultFilePath = Path.Combine(testDirectory.DirectoryPath, DiscoveryWorker.DiscoveryResultFileName);
+
+            // write a job file with a valid shape, but invalid requirement
+            await File.WriteAllTextAsync(jobFilePath, """
+                {
+                    "job": {
+                        "source": {
+                            "provider": "github",
+                            "repo": "test/repo"
+                        },
+                        "security-advisories": [
+                            {
+                                "dependency-name": "Some.Dependency",
+                                "affected-versions": ["not a valid requirement"]
+                            }
+                        ]
+                    }
+                }
+                """);
+            await RunAsync(path =>
+                [
+                    "discover",
+                    "--job-id",
+                    "TEST-JOB-ID",
+                    "--job-path",
+                    jobFilePath,
+                    "--repo-root",
+                    path,
+                    "--workspace",
+                    "/",
+                    "--output",
+                    resultFilePath
+                ],
+                initialFiles: [],
+                expectedResult: new()
+                {
+                    Path = "/",
+                    Projects = [],
+                    Error = new Core.Run.ApiModel.BadRequirement("not a valid requirement"),
+                }
+            );
+        }
+
         private static async Task RunAsync(
             Func<string, string[]> getArgs,
             TestFile[] initialFiles,
@@ -406,6 +496,7 @@ public partial class EntryPointTests
                 var originalErr = Console.Error;
                 Console.SetOut(writer);
                 Console.SetError(writer);
+                string? resultPath = null;
 
                 try
                 {
@@ -416,9 +507,15 @@ public partial class EntryPointTests
                     // manually pull out the experiments manager for the validate step below
                     for (int i = 0; i < args.Length - 1; i++)
                     {
-                        if (args[i] == "--job-path")
+                        switch (args[i])
                         {
-                            experimentsManager = await ExperimentsManager.FromJobFileAsync(args[i + 1], new TestLogger());
+                            case "--job-path":
+                                var experimentsResult = await ExperimentsManager.FromJobFileAsync("TEST-JOB-ID", args[i + 1]);
+                                experimentsManager = experimentsResult.ExperimentsManager;
+                                break;
+                            case "--output":
+                                resultPath = args[i + 1];
+                                break;
                         }
                     }
 
@@ -434,13 +531,40 @@ public partial class EntryPointTests
                     Console.SetError(originalErr);
                 }
 
-                var resultPath = Path.Join(path, DiscoveryWorker.DiscoveryResultFileName);
+                resultPath ??= Path.Join(path, DiscoveryWorker.DiscoveryResultFileName);
                 var resultJson = await File.ReadAllTextAsync(resultPath);
-                var resultObject = JsonSerializer.Deserialize<WorkspaceDiscoveryResult>(resultJson, DiscoveryWorker.SerializerOptions);
+                var serializerOptions = new JsonSerializerOptions()
+                {
+                    Converters = { new TestJobErrorBaseConverter() }
+                };
+                foreach (var converter in DiscoveryWorker.SerializerOptions.Converters)
+                {
+                    serializerOptions.Converters.Add(converter);
+                }
+                var resultObject = JsonSerializer.Deserialize<WorkspaceDiscoveryResult>(resultJson, serializerOptions);
                 return resultObject!;
             });
 
             ValidateWorkspaceResult(expectedResult, actualResult, experimentsManager);
         }
+
+        private class TestJobErrorBaseConverter : JsonConverter<Core.Run.ApiModel.JobErrorBase>
+        {
+            public override Core.Run.ApiModel.JobErrorBase? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                var dict = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(ref reader, options)!;
+                return dict["error-type"].GetString() switch
+                {
+                    "illformed_requirement" => new Core.Run.ApiModel.BadRequirement(dict["error-details"].GetProperty("message").GetString()!),
+                    "unknown_error" => new Core.Run.ApiModel.UnknownError(new Exception("Error deserializing job file contents"), "TEST-JOB-ID"),
+                    _ => throw new NotImplementedException($"Unknown error type: {dict["error-type"]}"),
+                };
+            }
+
+            public override void Write(Utf8JsonWriter writer, Core.Run.ApiModel.JobErrorBase value, JsonSerializerOptions options)
+            {
+                throw new NotImplementedException();
+            }
+        }
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli.Test/EntryPointTests.Update.cs

@@ -19,6 +19,8 @@ public partial class EntryPointTests
             await Run(path =>
                 [
                     "update",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     Path.Combine(path, "job.json"),
                     "--repo-root",
@@ -122,6 +124,8 @@ public partial class EntryPointTests
             await Run(path =>
                 [
                     "update",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     Path.Combine(path, "job.json"),
                     "--repo-root",
@@ -202,6 +206,8 @@ public partial class EntryPointTests
             await Run(path =>
                 [
                     "update",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     Path.Combine(path, "job.json"),
                     "--repo-root",
@@ -361,6 +367,8 @@ public partial class EntryPointTests
             IEnumerable<string> executableArgs = [
                 executableName,
                 "update",
+                "--job-id",
+                "TEST-JOB-ID",
                 "--job-path",
                 Path.Combine(tempDir.DirectoryPath, "job.json"),
                 "--repo-root",