dependabot-nuget 0.292.0 → 0.294.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, _errorResult) = await ExperimentsManager.FromJobFileAsync(jobPath.FullName);
-            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/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,27 +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, errorResult) = await ExperimentsManager.FromJobFileAsync(jobPath.FullName);
-            if (errorResult is not null)
+            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 = [],
-                    ErrorType = errorResult.ErrorType,
-                    ErrorDetails = errorResult.ErrorDetails,
                 };
                 await DiscoveryWorker.WriteResultsAsync(repoRoot.FullName, outputPath.FullName, discoveryErrorResult);
                 return;
             }
 
             var logger = new ConsoleLogger();
-            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,11 +33,11 @@ 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(jobPath.FullName);
+            var (experimentsManager, _errorResult) = await ExperimentsManager.FromJobFileAsync(jobId, jobPath.FullName);
             var logger = new ConsoleLogger();
-            var discoverWorker = new DiscoveryWorker(experimentsManager, logger);
-            var analyzeWorker = new AnalyzeWorker(experimentsManager, logger);
-            var updateWorker = new UpdaterWorker(experimentsManager, 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) =>
         {
-            var (experimentsManager, _errorResult) = await ExperimentsManager.FromJobFileAsync(jobPath.FullName);
+            // 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 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,7 @@ public partial class EntryPointTests
                     {
                         if (args[i] == "--job-path")
                         {
-                            var experimentsResult = await ExperimentsManager.FromJobFileAsync(args[i + 1]);
+                            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",
@@ -398,6 +409,8 @@ public partial class EntryPointTests
             await RunAsync(path =>
                 [
                     "discover",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     jobFilePath,
                     "--repo-root",
@@ -412,8 +425,7 @@ public partial class EntryPointTests
                 {
                     Path = "/",
                     Projects = [],
-                    ErrorType = ErrorType.Unknown,
-                    ErrorDetailsPattern = "JsonException",
+                    ErrorRegex = "Error deserializing job file contents",
                 }
             );
         }
@@ -445,6 +457,8 @@ public partial class EntryPointTests
             await RunAsync(path =>
                 [
                     "discover",
+                    "--job-id",
+                    "TEST-JOB-ID",
                     "--job-path",
                     jobFilePath,
                     "--repo-root",
@@ -459,8 +473,7 @@ public partial class EntryPointTests
                 {
                     Path = "/",
                     Projects = [],
-                    ErrorType = ErrorType.BadRequirement,
-                    ErrorDetailsPattern = "not a valid requirement",
+                    Error = new Core.Run.ApiModel.BadRequirement("not a valid requirement"),
                 }
             );
         }
@@ -497,7 +510,7 @@ public partial class EntryPointTests
                         switch (args[i])
                         {
                             case "--job-path":
-                                var experimentsResult = await ExperimentsManager.FromJobFileAsync(args[i + 1]);
+                                var experimentsResult = await ExperimentsManager.FromJobFileAsync("TEST-JOB-ID", args[i + 1]);
                                 experimentsManager = experimentsResult.ExperimentsManager;
                                 break;
                             case "--output":
@@ -520,11 +533,38 @@ public partial class EntryPointTests
 
                 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",

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/AnalyzeWorker.cs

@@ -7,6 +7,7 @@ using NuGet.Frameworks;
 using NuGet.Versioning;
 
 using NuGetUpdater.Core.Discover;
+using NuGetUpdater.Core.Run.ApiModel;
 
 namespace NuGetUpdater.Core.Analyze;
 
@@ -16,6 +17,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
 {
     public const string AnalysisDirectoryName = "./.dependabot/analysis";
 
+    private readonly string _jobId;
     private readonly ExperimentsManager _experimentsManager;
     private readonly ILogger _logger;
 
@@ -25,8 +27,9 @@ public partial class AnalyzeWorker : IAnalyzeWorker
         Converters = { new JsonStringEnumConverter(), new RequirementArrayConverter() },
     };
 
-    public AnalyzeWorker(ExperimentsManager experimentsManager, ILogger logger)
+    public AnalyzeWorker(string jobId, ExperimentsManager experimentsManager, ILogger logger)
     {
+        _jobId = jobId;
         _experimentsManager = experimentsManager;
         _logger = logger;
     }
@@ -48,26 +51,11 @@ public partial class AnalyzeWorker : IAnalyzeWorker
         {
             analysisResult = await RunAsync(repoRoot, discovery, dependencyInfo);
         }
-        catch (HttpRequestException ex)
-        when (ex.StatusCode == HttpStatusCode.Unauthorized || ex.StatusCode == HttpStatusCode.Forbidden)
-        {
-            var localPath = PathHelper.JoinPath(repoRoot, discovery.Path);
-            using var nugetContext = new NuGetContext(localPath);
-            analysisResult = new AnalysisResult
-            {
-                ErrorType = ErrorType.AuthenticationFailure,
-                ErrorDetails = "(" + string.Join("|", nugetContext.PackageSources.Select(s => s.Source)) + ")",
-                UpdatedVersion = string.Empty,
-                CanUpdate = false,
-                UpdatedDependencies = [],
-            };
-        }
         catch (Exception ex)
         {
             analysisResult = new AnalysisResult
             {
-                ErrorType = ErrorType.Unknown,
-                ErrorDetails = ex.ToString(),
+                Error = JobErrorBase.ErrorFromException(ex, _jobId, PathHelper.JoinPath(repoRoot, discovery.Path)),
                 UpdatedVersion = string.Empty,
                 CanUpdate = false,
                 UpdatedDependencies = [],
@@ -79,6 +67,8 @@ public partial class AnalyzeWorker : IAnalyzeWorker
 
     public async Task<AnalysisResult> RunAsync(string repoRoot, WorkspaceDiscoveryResult discovery, DependencyInfo dependencyInfo)
     {
+        MSBuildHelper.RegisterMSBuild(repoRoot, repoRoot);
+
         var startingDirectory = PathHelper.JoinPath(repoRoot, discovery.Path);
 
         _logger.Info($"Starting analysis of {dependencyInfo.Name}...");
@@ -423,6 +413,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
             .SelectMany(p => p.TargetFrameworks)
             .Select(NuGetFramework.Parse)
             .Distinct()
+            .Select(f => f.GetShortFolderName())
             .ToImmutableArray();
 
         // When updating peer dependencies, we only need to consider top-level dependencies.

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/DependencyFinder.cs

@@ -7,10 +7,10 @@ namespace NuGetUpdater.Core.Analyze;
 
 internal static class DependencyFinder
 {
-    public static async Task<ImmutableDictionary<NuGetFramework, ImmutableArray<Dependency>>> GetDependenciesAsync(
+    public static async Task<ImmutableDictionary<string, ImmutableArray<Dependency>>> GetDependenciesAsync(
         string repoRoot,
         string projectPath,
-        IEnumerable<NuGetFramework> frameworks,
+        IEnumerable<string> frameworks,
         ImmutableHashSet<string> packageIds,
         NuGetVersion version,
         NuGetContext nugetContext,
@@ -23,13 +23,13 @@ internal static class DependencyFinder
             .Select(id => new Dependency(id, versionString, DependencyType.Unknown))
             .ToImmutableArray();
 
-        var result = ImmutableDictionary.CreateBuilder<NuGetFramework, ImmutableArray<Dependency>>();
+        var result = ImmutableDictionary.CreateBuilder<string, ImmutableArray<Dependency>>();
         foreach (var framework in frameworks)
         {
             var dependencies = await MSBuildHelper.GetAllPackageDependenciesAsync(
                 repoRoot,
                 projectPath,
-                framework.ToString(),
+                framework,
                 packages,
                 experimentsManager,
                 logger);

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/Extensions.cs

@@ -7,7 +7,7 @@ using NuGetUpdater.Core;
 
 internal static class Extensions
 {
-    public static ImmutableArray<Dependency> GetDependencies(this ImmutableDictionary<NuGetFramework, ImmutableArray<Dependency>> dependenciesByTfm)
+    public static ImmutableArray<Dependency> GetDependencies(this ImmutableDictionary<string, ImmutableArray<Dependency>> dependenciesByTfm)
     {
         Dictionary<string, Dependency> dependencies = [];
         foreach (var (_framework, dependenciesForTfm) in dependenciesByTfm)