dependabot-nuget 0.277.0 → 0.279.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 492a5ffafd58adff4054fe829df3b316905a6c8bcfad5f291f9caa7653118a43
-  data.tar.gz: 75fbd529bc36ec77ae4b849c62a612272586803cc7792af3b5ce1bdd76bd592c
+  metadata.gz: 644fb3ec407649eb15e5e9ab7be78a85f8f03900adcc93819e3be781610cf78e
+  data.tar.gz: 408ef4e6a5d517d159256429a2d68d61bc0e0188e3f0c13a4c0aa6b00b55e74b
 SHA512:
-  metadata.gz: d4ebd69a7d512170e67677cc9a92bb1a791d92fc8591cf05d405da86449d523796cb0074afeb856ead16a074926ebca38d0173b7265cdc0941f271ecb1e8a575
-  data.tar.gz: 1fe2bb3b9f317dfd931ec36efb5b0faa6689860c40595cec827c5f3a3666789a793a2350ed1f0f72612539fa9d1641858b693d115579166fd9c5f36c698976ce
+  metadata.gz: 25125733df999707391798277975f970cfcf4bd87809165612d600a245d758e9bad553e046c8a0ff566446a90426c6719fedffa3a82139212c6f106de412bea7
+  data.tar.gz: 5db427ffb67c418e0f99dcc3f83a5f320a7fc3aaff177425a5c32d9b48b3296495c9fdc5f0fbd0959c2da0cc0b35132a532b1ec83af494950df15d3fa076435e

data/helpers/build

@@ -32,7 +32,7 @@ cd "$install_dir/lib/NuGetUpdater/NuGetUpdater.Cli"
 dotnet publish \
     --configuration Release \
     --output "$install_dir/NuGetUpdater" \
-    --framework net8.0 \
+    --framework net9.0 \
     --runtime "$os-$arch"
 dotnet clean
 

data/helpers/lib/NuGetUpdater/.editorconfig

@@ -20,6 +20,7 @@ tab_width = 4
 
 # New line preferences
 insert_final_newline = true
+end_of_line = lf
 
 #### .NET Coding Conventions ####
 [*.{cs,vb}]

data/helpers/lib/NuGetUpdater/Directory.Build.props

@@ -1,6 +1,7 @@
 <Project>
 
   <PropertyGroup>
+    <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
     <NoWarn>$(NoWarn);NU1701</NoWarn>
     <Nullable>enable</Nullable>
   </PropertyGroup>

data/helpers/lib/NuGetUpdater/Directory.Common.props

@@ -9,7 +9,7 @@
             NuGetUpdater\NuGetUpdater.Core\FrameworkChecker\SupportedFrameworks.cs
       2. Update tests as needed at `NuGetUpdater\NuGetUpdater.Core.Test\FrameworkChecker\CompatibilityCheckerFacts.cs`
     -->
-    <CommonTargetFramework>net8.0</CommonTargetFramework>
+    <CommonTargetFramework>net9.0</CommonTargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <UseArtifactsOutput>true</UseArtifactsOutput>
     <ArtifactsPath>$(MSBuildThisFileDirectory)artifacts</ArtifactsPath>

data/helpers/lib/NuGetUpdater/Directory.Packages.props

@@ -7,7 +7,7 @@
   <ItemGroup>
     <PackageVersion Include="DiffPlex" Version="1.7.1" />
 
-    <PackageVersion Include="GuiLabs.Language.Xml" Version="1.2.60" />
+    <PackageVersion Include="GuiLabs.Language.Xml" Version="1.2.93" />
 
     <PackageVersion Include="Microsoft.Build.Locator" Version="1.6.1" />
     <PackageVersion Include="Microsoft.Build" Version="17.5.0" ExcludeAssets="Runtime" PrivateAssets="All" />
@@ -20,6 +20,11 @@
     <PackageVersion Include="NuGet.Core" Version="2.14.0-rtm-832" Aliases="CoreV2" />
 
     <PackageVersion Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
+    <PackageVersion Include="System.Net.Http" Version="4.3.4" />
+    <PackageVersion Include="System.Formats.Asn1" Version="8.0.1" />
+    <PackageVersion Include="System.Security.Cryptography.Pkcs" Version="8.0.0" />
+    <PackageVersion Include="System.Text.Json" Version="8.0.4" />
+    <PackageVersion Include="System.Text.RegularExpressions" Version="4.3.1" />
 
     <PackageVersion Include="xunit" Version="2.4.2" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="2.4.5" />

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

@@ -0,0 +1,42 @@
+using System.CommandLine;
+
+using NuGetUpdater.Core;
+using NuGetUpdater.Core.Run;
+
+namespace NuGetUpdater.Cli.Commands;
+
+internal static class RunCommand
+{
+    internal static readonly Option<FileInfo> JobPathOption = new("--job-path") { IsRequired = true };
+    internal static readonly Option<DirectoryInfo> RepoContentsPathOption = new("--repo-contents-path") { IsRequired = true };
+    internal static readonly Option<Uri> ApiUrlOption = new("--api-url") { IsRequired = true };
+    internal static readonly Option<string> JobIdOption = new("--job-id") { IsRequired = true };
+    internal static readonly Option<FileInfo> OutputPathOption = new("--output-path") { IsRequired = true };
+    internal static readonly Option<string> BaseCommitShaOption = new("--base-commit-sha") { IsRequired = true };
+    internal static readonly Option<bool> VerboseOption = new("--verbose", getDefaultValue: () => false);
+
+    internal static Command GetCommand(Action<int> setExitCode)
+    {
+        Command command = new("run", "Runs a full dependabot job.")
+        {
+            JobPathOption,
+            RepoContentsPathOption,
+            ApiUrlOption,
+            JobIdOption,
+            OutputPathOption,
+            BaseCommitShaOption,
+            VerboseOption
+        };
+
+        command.TreatUnmatchedTokensAsErrors = true;
+
+        command.SetHandler(async (jobPath, repoContentsPath, apiUrl, jobId, outputPath, baseCommitSha, verbose) =>
+        {
+            var apiHandler = new HttpApiHandler(apiUrl.ToString(), jobId);
+            var worker = new RunWorker(apiHandler, new Logger(verbose));
+            await worker.RunAsync(jobPath, repoContentsPath, baseCommitSha, outputPath);
+        }, JobPathOption, RepoContentsPathOption, ApiUrlOption, JobIdOption, OutputPathOption, BaseCommitShaOption, VerboseOption);
+
+        return command;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli/Program.cs

@@ -17,6 +17,7 @@ internal sealed class Program
             DiscoverCommand.GetCommand(setExitCode),
             AnalyzeCommand.GetCommand(setExitCode),
             UpdateCommand.GetCommand(setExitCode),
+            RunCommand.GetCommand(setExitCode),
         };
         command.TreatUnmatchedTokensAsErrors = true;
 

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

@@ -0,0 +1,132 @@
+using System.Text;
+using System.Text.Json;
+
+using NuGetUpdater.Core.Run;
+using NuGetUpdater.Core.Run.ApiModel;
+using NuGetUpdater.Core.Test;
+using NuGetUpdater.Core.Test.Update;
+
+using Xunit;
+
+namespace NuGetUpdater.Cli.Test;
+
+using TestFile = (string Path, string Content);
+
+public partial class EntryPointTests
+{
+    public class Run
+    {
+        [Fact]
+        public async Task Run_Simple()
+        {
+            // verify we can pass command line arguments and hit the appropriate URLs
+            await RunAsync(
+                packages:
+                [
+                    MockNuGetPackage.CreateSimplePackage("Some.Package", "1.0.0", "net8.0"),
+                    MockNuGetPackage.CreateSimplePackage("Some.Package", "1.0.1", "net8.0"),
+                ],
+                files:
+                [
+                    ("src/project.csproj", """
+                        <Project Sdk="Microsoft.NET.Sdk">
+                          <PropertyGroup>
+                            <TargetFramework>net8.0</TargetFramework>
+                          </PropertyGroup>
+                          <ItemGroup>
+                            <PackageReference Include="Some.Package" Version="1.0.0" />
+                          </ItemGroup>
+                        </Project>
+                        """)
+                ],
+                job: new Job()
+                {
+                    PackageManager = "nuget",
+                    AllowedUpdates = [
+                        new()
+                        {
+                            UpdateType = "all"
+                        }
+                    ],
+                    Source = new()
+                    {
+                        Provider = "github",
+                        Repo = "test",
+                        Directory = "src",
+                    }
+                },
+                expectedUrls:
+                [
+                    "/update_jobs/TEST-ID/update_dependency_list",
+                    "/update_jobs/TEST-ID/increment_metric",
+                    "/update_jobs/TEST-ID/create_pull_request",
+                    "/update_jobs/TEST-ID/mark_as_processed",
+                ]
+            );
+        }
+
+        private static async Task RunAsync(TestFile[] files, Job job, string[] expectedUrls, MockNuGetPackage[]? packages = null)
+        {
+            using var tempDirectory = new TemporaryDirectory();
+
+            // write test files
+            foreach (var testFile in files)
+            {
+                var fullPath = Path.Join(tempDirectory.DirectoryPath, testFile.Path);
+                var directory = Path.GetDirectoryName(fullPath)!;
+                Directory.CreateDirectory(directory);
+                await File.WriteAllTextAsync(fullPath, testFile.Content);
+            }
+
+            // write job file
+            var jobPath = Path.Combine(tempDirectory.DirectoryPath, "job.json");
+            await File.WriteAllTextAsync(jobPath, JsonSerializer.Serialize(new { Job = job }, RunWorker.SerializerOptions));
+
+            // save packages
+            await UpdateWorkerTestBase.MockNuGetPackagesInDirectory(packages, tempDirectory.DirectoryPath);
+
+            var actualUrls = new List<string>();
+            using var http = TestHttpServer.CreateTestStringServer(url =>
+            {
+                actualUrls.Add(new Uri(url).PathAndQuery);
+                return (200, "ok");
+            });
+            var args = new List<string>()
+            {
+                "run",
+                "--job-path",
+                jobPath,
+                "--repo-contents-path",
+                tempDirectory.DirectoryPath,
+                "--api-url",
+                http.BaseUrl,
+                "--job-id",
+                "TEST-ID",
+                "--output-path",
+                Path.Combine(tempDirectory.DirectoryPath, "output.json"),
+                "--base-commit-sha",
+                "BASE-COMMIT-SHA",
+                "--verbose"
+            };
+
+            var output = new StringBuilder();
+            // redirect stdout
+            var originalOut = Console.Out;
+            Console.SetOut(new StringWriter(output));
+            int result = -1;
+            try
+            {
+                result = await Program.Main(args.ToArray());
+            }
+            catch
+            {
+                // restore stdout
+                Console.SetOut(originalOut);
+                throw;
+            }
+
+            Assert.True(result == 0, output.ToString());
+            Assert.Equal(expectedUrls, actualUrls);
+        }
+    }
+}

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

@@ -352,8 +352,7 @@ public partial class EntryPointTests
                 </Project>
                 """);
             var executableName = Path.Join(Path.GetDirectoryName(GetType().Assembly.Location), "NuGetUpdater.Cli.dll");
-            var executableArgs = string.Join(" ",
-            [
+            IEnumerable<string> executableArgs = [
                 executableName,
                 "update",
                 "--repo-root",
@@ -367,7 +366,7 @@ public partial class EntryPointTests
                 "--previous-version",
                 "7.0.1",
                 "--verbose"
-            ]);
+            ];
 
             // verify base run
             var workingDirectory = tempDir.DirectoryPath;

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

@@ -31,8 +31,34 @@ public partial class AnalyzeWorker
 
     public async Task RunAsync(string repoRoot, string discoveryPath, string dependencyPath, string analysisDirectory)
     {
+        AnalysisResult analysisResult;
         var discovery = await DeserializeJsonFileAsync<WorkspaceDiscoveryResult>(discoveryPath, nameof(WorkspaceDiscoveryResult));
         var dependencyInfo = await DeserializeJsonFileAsync<DependencyInfo>(dependencyPath, nameof(DependencyInfo));
+
+        try
+        {
+            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);
+            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 = [],
+            };
+        }
+
+        await WriteResultsAsync(analysisDirectory, dependencyInfo.Name, analysisResult, _logger);
+    }
+
+    public async Task<AnalysisResult> RunAsync(string repoRoot, WorkspaceDiscoveryResult discovery, DependencyInfo dependencyInfo)
+    {
         var startingDirectory = PathHelper.JoinPath(repoRoot, discovery.Path);
 
         _logger.Log($"Starting analysis of {dependencyInfo.Name}...");
@@ -61,104 +87,87 @@ public partial class AnalyzeWorker
         bool isProjectUpdateNecessary = IsUpdateNecessary(dependencyInfo, projectsWithDependency);
         var isUpdateNecessary = isProjectUpdateNecessary || dotnetToolsHasDependency || globalJsonHasDependency;
         using var nugetContext = new NuGetContext(startingDirectory);
-        AnalysisResult result;
-        try
+        AnalysisResult analysisResult;
+        if (isUpdateNecessary)
         {
-            if (isUpdateNecessary)
+            _logger.Log($"  Determining multi-dependency property.");
+            var multiDependencies = DetermineMultiDependencyDetails(
+                discovery,
+                dependencyInfo.Name,
+                propertyBasedDependencies);
+
+            usesMultiDependencyProperty = multiDependencies.Any(md => md.DependencyNames.Count > 1);
+            var dependenciesToUpdate = usesMultiDependencyProperty
+                ? multiDependencies
+                    .SelectMany(md => md.DependencyNames)
+                    .ToImmutableHashSet(StringComparer.OrdinalIgnoreCase)
+                : [dependencyInfo.Name];
+            var applicableTargetFrameworks = usesMultiDependencyProperty
+                ? multiDependencies
+                    .SelectMany(md => md.TargetFrameworks)
+                    .ToImmutableHashSet(StringComparer.OrdinalIgnoreCase)
+                    .Select(NuGetFramework.Parse)
+                    .ToImmutableArray()
+                : projectFrameworks;
+
+            _logger.Log($"  Finding updated version.");
+            updatedVersion = await FindUpdatedVersionAsync(
+                startingDirectory,
+                dependencyInfo,
+                dependenciesToUpdate,
+                applicableTargetFrameworks,
+                nugetContext,
+                _logger,
+                CancellationToken.None);
+
+            _logger.Log($"  Finding updated peer dependencies.");
+            if (updatedVersion is null)
             {
-                _logger.Log($"  Determining multi-dependency property.");
-                var multiDependencies = DetermineMultiDependencyDetails(
+                updatedDependencies = [];
+            }
+            else if (isProjectUpdateNecessary)
+            {
+                updatedDependencies = await FindUpdatedDependenciesAsync(
+                    repoRoot,
                     discovery,
-                    dependencyInfo.Name,
-                    propertyBasedDependencies);
-
-                usesMultiDependencyProperty = multiDependencies.Any(md => md.DependencyNames.Count > 1);
-                var dependenciesToUpdate = usesMultiDependencyProperty
-                    ? multiDependencies
-                        .SelectMany(md => md.DependencyNames)
-                        .ToImmutableHashSet(StringComparer.OrdinalIgnoreCase)
-                    : [dependencyInfo.Name];
-                var applicableTargetFrameworks = usesMultiDependencyProperty
-                    ? multiDependencies
-                        .SelectMany(md => md.TargetFrameworks)
-                        .ToImmutableHashSet(StringComparer.OrdinalIgnoreCase)
-                        .Select(NuGetFramework.Parse)
-                        .ToImmutableArray()
-                    : projectFrameworks;
-
-                _logger.Log($"  Finding updated version.");
-                updatedVersion = await FindUpdatedVersionAsync(
-                    startingDirectory,
-                    dependencyInfo,
                     dependenciesToUpdate,
-                    applicableTargetFrameworks,
+                    updatedVersion,
                     nugetContext,
                     _logger,
                     CancellationToken.None);
-
-                _logger.Log($"  Finding updated peer dependencies.");
-                if (updatedVersion is null)
-                {
-                    updatedDependencies = [];
-                }
-                else if (isProjectUpdateNecessary)
-                {
-                    updatedDependencies = await FindUpdatedDependenciesAsync(
-                        repoRoot,
-                        discovery,
-                        dependenciesToUpdate,
-                        updatedVersion,
-                        nugetContext,
-                        _logger,
-                        CancellationToken.None);
-                }
-                else if (dotnetToolsHasDependency)
-                {
-                    var infoUrl = await nugetContext.GetPackageInfoUrlAsync(dependencyInfo.Name, updatedVersion.ToNormalizedString(), CancellationToken.None);
-                    updatedDependencies = [new Dependency(dependencyInfo.Name, updatedVersion.ToNormalizedString(), DependencyType.DotNetTool, IsDirect: true, InfoUrl: infoUrl)];
-                }
-                else if (globalJsonHasDependency)
-                {
-                    var infoUrl = await nugetContext.GetPackageInfoUrlAsync(dependencyInfo.Name, updatedVersion.ToNormalizedString(), CancellationToken.None);
-                    updatedDependencies = [new Dependency(dependencyInfo.Name, updatedVersion.ToNormalizedString(), DependencyType.MSBuildSdk, IsDirect: true, InfoUrl: infoUrl)];
-                }
-                else
-                {
-                    throw new InvalidOperationException("Unreachable.");
-                }
-
-                //TODO: At this point we should add the peer dependencies to a queue where
-                // we will analyze them one by one to see if they themselves are part of a
-                // multi-dependency property. Basically looping this if-body until we have
-                // emptied the queue and have a complete list of updated dependencies. We
-                // should track the dependenciesToUpdate as they have already been analyzed.
             }
-
-            result = new AnalysisResult
+            else if (dotnetToolsHasDependency)
             {
-                UpdatedVersion = updatedVersion?.ToNormalizedString() ?? dependencyInfo.Version,
-                CanUpdate = updatedVersion is not null,
-                VersionComesFromMultiDependencyProperty = usesMultiDependencyProperty,
-                UpdatedDependencies = updatedDependencies,
-            };
-        }
-        catch (HttpRequestException ex)
-        when (ex.StatusCode == HttpStatusCode.Unauthorized || ex.StatusCode == HttpStatusCode.Forbidden)
-        {
-            // TODO: consolidate this error handling between AnalyzeWorker, DiscoveryWorker, and UpdateWorker
-            result = new AnalysisResult
+                var infoUrl = await nugetContext.GetPackageInfoUrlAsync(dependencyInfo.Name, updatedVersion.ToNormalizedString(), CancellationToken.None);
+                updatedDependencies = [new Dependency(dependencyInfo.Name, updatedVersion.ToNormalizedString(), DependencyType.DotNetTool, IsDirect: true, InfoUrl: infoUrl)];
+            }
+            else if (globalJsonHasDependency)
             {
-                ErrorType = ErrorType.AuthenticationFailure,
-                ErrorDetails = "(" + string.Join("|", nugetContext.PackageSources.Select(s => s.Source)) + ")",
-                UpdatedVersion = string.Empty,
-                CanUpdate = false,
-                UpdatedDependencies = [],
-            };
+                var infoUrl = await nugetContext.GetPackageInfoUrlAsync(dependencyInfo.Name, updatedVersion.ToNormalizedString(), CancellationToken.None);
+                updatedDependencies = [new Dependency(dependencyInfo.Name, updatedVersion.ToNormalizedString(), DependencyType.MSBuildSdk, IsDirect: true, InfoUrl: infoUrl)];
+            }
+            else
+            {
+                throw new InvalidOperationException("Unreachable.");
+            }
+
+            //TODO: At this point we should add the peer dependencies to a queue where
+            // we will analyze them one by one to see if they themselves are part of a
+            // multi-dependency property. Basically looping this if-body until we have
+            // emptied the queue and have a complete list of updated dependencies. We
+            // should track the dependenciesToUpdate as they have already been analyzed.
         }
 
-        await WriteResultsAsync(analysisDirectory, dependencyInfo.Name, result, _logger);
+        analysisResult = new AnalysisResult
+        {
+            UpdatedVersion = updatedVersion?.ToNormalizedString() ?? dependencyInfo.Version,
+            CanUpdate = updatedVersion is not null,
+            VersionComesFromMultiDependencyProperty = usesMultiDependencyProperty,
+            UpdatedDependencies = updatedDependencies,
+        };
 
         _logger.Log($"Analysis complete.");
+        return analysisResult;
     }
 
     private static bool IsUpdateNecessary(DependencyInfo dependencyInfo, ImmutableArray<ProjectDiscoveryResult> projectsWithDependency)
@@ -393,7 +402,7 @@ public partial class AnalyzeWorker
 
         // Create distinct list of dependencies taking the highest version of each
         var dependencyResult = await DependencyFinder.GetDependenciesAsync(
-            workspacePath,
+            repoRoot,
             projectPath,
             projectFrameworks,
             packageIds,

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

@@ -8,7 +8,7 @@ namespace NuGetUpdater.Core.Analyze;
 internal static class DependencyFinder
 {
     public static async Task<ImmutableDictionary<NuGetFramework, ImmutableArray<Dependency>>> GetDependenciesAsync(
-        string workspacePath,
+        string repoRoot,
         string projectPath,
         IEnumerable<NuGetFramework> frameworks,
         ImmutableHashSet<string> packageIds,
@@ -26,7 +26,7 @@ internal static class DependencyFinder
         foreach (var framework in frameworks)
         {
             var dependencies = await MSBuildHelper.GetAllPackageDependenciesAsync(
-                workspacePath,
+                repoRoot,
                 projectPath,
                 framework.ToString(),
                 packages,

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

@@ -52,10 +52,10 @@ public abstract class Requirement
 
     public static Requirement Parse(string requirement)
     {
-        var specificParts = requirement.Split(',');
+        var specificParts = requirement.Split(',').Where(p => !string.IsNullOrWhiteSpace(p)).ToArray();
         if (specificParts.Length == 1)
         {
-            return IndividualRequirement.ParseIndividual(requirement);
+            return IndividualRequirement.ParseIndividual(specificParts[0]);
         }
 
         var specificRequirements = specificParts.Select(IndividualRequirement.ParseIndividual).ToArray();

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/DiscoveryWorker.cs

@@ -31,6 +31,28 @@ public partial class DiscoveryWorker
     }
 
     public async Task RunAsync(string repoRootPath, string workspacePath, string outputPath)
+    {
+        WorkspaceDiscoveryResult result;
+        try
+        {
+            result = await RunAsync(repoRootPath, workspacePath);
+        }
+        catch (HttpRequestException ex)
+        when (ex.StatusCode == HttpStatusCode.Unauthorized || ex.StatusCode == HttpStatusCode.Forbidden)
+        {
+            result = new WorkspaceDiscoveryResult
+            {
+                ErrorType = ErrorType.AuthenticationFailure,
+                ErrorDetails = "(" + string.Join("|", NuGetContext.GetPackageSourceUrls(PathHelper.JoinPath(repoRootPath, workspacePath))) + ")",
+                Path = workspacePath,
+                Projects = [],
+            };
+        }
+
+        await WriteResultsAsync(repoRootPath, outputPath, result);
+    }
+
+    internal async Task<WorkspaceDiscoveryResult> RunAsync(string repoRootPath, string workspacePath)
     {
         MSBuildHelper.RegisterMSBuild(Environment.CurrentDirectory, repoRootPath);
 
@@ -51,62 +73,46 @@ public partial class DiscoveryWorker
         ImmutableArray<ProjectDiscoveryResult> projectResults = [];
         WorkspaceDiscoveryResult result;
 
-        try
+        if (Directory.Exists(workspacePath))
         {
-            if (Directory.Exists(workspacePath))
-            {
-                _logger.Log($"Discovering build files in workspace [{workspacePath}].");
+            _logger.Log($"Discovering build files in workspace [{workspacePath}].");
 
-                dotNetToolsJsonDiscovery = DotNetToolsJsonDiscovery.Discover(repoRootPath, workspacePath, _logger);
-                globalJsonDiscovery = GlobalJsonDiscovery.Discover(repoRootPath, workspacePath, _logger);
+            dotNetToolsJsonDiscovery = DotNetToolsJsonDiscovery.Discover(repoRootPath, workspacePath, _logger);
+            globalJsonDiscovery = GlobalJsonDiscovery.Discover(repoRootPath, workspacePath, _logger);
 
-                if (globalJsonDiscovery is not null)
-                {
-                    await TryRestoreMSBuildSdksAsync(repoRootPath, workspacePath, globalJsonDiscovery.Dependencies, _logger);
-                }
+            if (globalJsonDiscovery is not null)
+            {
+                await TryRestoreMSBuildSdksAsync(repoRootPath, workspacePath, globalJsonDiscovery.Dependencies, _logger);
+            }
 
-                // this next line should throw or something
-                projectResults = await RunForDirectoryAsnyc(repoRootPath, workspacePath);
+            // this next line should throw or something
+            projectResults = await RunForDirectoryAsnyc(repoRootPath, workspacePath);
 
-                directoryPackagesPropsDiscovery = DirectoryPackagesPropsDiscovery.Discover(repoRootPath, workspacePath, projectResults, _logger);
+            directoryPackagesPropsDiscovery = DirectoryPackagesPropsDiscovery.Discover(repoRootPath, workspacePath, projectResults, _logger);
 
-                if (directoryPackagesPropsDiscovery is not null)
-                {
-                    projectResults = projectResults.Remove(projectResults.First(p => p.FilePath.Equals(directoryPackagesPropsDiscovery.FilePath, StringComparison.OrdinalIgnoreCase)));
-                }
-            }
-            else
+            if (directoryPackagesPropsDiscovery is not null)
             {
-                _logger.Log($"Workspace path [{workspacePath}] does not exist.");
+                projectResults = projectResults.Remove(projectResults.First(p => p.FilePath.Equals(directoryPackagesPropsDiscovery.FilePath, StringComparison.OrdinalIgnoreCase)));
             }
-
-            result = new WorkspaceDiscoveryResult
-            {
-                Path = initialWorkspacePath,
-                DotNetToolsJson = dotNetToolsJsonDiscovery,
-                GlobalJson = globalJsonDiscovery,
-                DirectoryPackagesProps = directoryPackagesPropsDiscovery,
-                Projects = projectResults.OrderBy(p => p.FilePath).ToImmutableArray(),
-            };
         }
-        catch (HttpRequestException ex)
-        when (ex.StatusCode == HttpStatusCode.Unauthorized || ex.StatusCode == HttpStatusCode.Forbidden)
+        else
         {
-            // TODO: consolidate this error handling between AnalyzeWorker, DiscoveryWorker, and UpdateWorker
-            result = new WorkspaceDiscoveryResult
-            {
-                ErrorType = ErrorType.AuthenticationFailure,
-                ErrorDetails = "(" + string.Join("|", NuGetContext.GetPackageSourceUrls(workspacePath)) + ")",
-                Path = initialWorkspacePath,
-                Projects = [],
-            };
+            _logger.Log($"Workspace path [{workspacePath}] does not exist.");
         }
 
-        await WriteResultsAsync(repoRootPath, outputPath, result);
+        result = new WorkspaceDiscoveryResult
+        {
+            Path = initialWorkspacePath,
+            DotNetToolsJson = dotNetToolsJsonDiscovery,
+            GlobalJson = globalJsonDiscovery,
+            DirectoryPackagesProps = directoryPackagesPropsDiscovery,
+            Projects = projectResults.OrderBy(p => p.FilePath).ToImmutableArray(),
+        };
 
         _logger.Log("Discovery complete.");
-
         _processedProjectPaths.Clear();
+
+        return result;
     }
 
     /// <summary>

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/NuGetUpdater.Core.csproj

@@ -21,7 +21,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <InternalsVisibleTo Include="NuGetUpdater.Core.Test"/>
+    <InternalsVisibleTo Include="NuGetUpdater.Cli.Test" />
+    <InternalsVisibleTo Include="NuGetUpdater.Core.Test" />
   </ItemGroup>
 
 </Project>

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/AllowedUpdate.cs

@@ -0,0 +1,6 @@
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public sealed record AllowedUpdate
+{
+    public string UpdateType { get; init; } = "all";
+}