dependabot-nuget 0.311.0 → 0.312.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a32c81e06aafe3606a77d89ae351b246b6e80c9fd272bfe0001e6486eebf989b
-  data.tar.gz: 7796df4d53b7b86d9ea7472ff82fd4801dd7144d93b087fe32423dfb535c50e5
+  metadata.gz: acb9d775c29330f4cae905aa23b7ad9c36f0ed161d8cc1c2fbfc7391fb52646b
+  data.tar.gz: 97b60783a35914969fe10efc5235a91d29a470faf40e4520cf331bf6bafe21f1
 SHA512:
-  metadata.gz: b487988ea2bc084a70c73216d9ab773be814a442c3a9e160374ae5bdefd03e9067ca9b7cc12d55725da0396e3e14af7bb1cb037742ac7f2aba7c9b65130cfb8a
-  data.tar.gz: 281290949ba2b0dccaff75e68aaeab2e886721cc19c79cf379ce5302cbe719f2fa7e1ec491720a30f3bda4617136c03e7b8e8a4dc20fef9c6632f79ed3c0a9ae
+  metadata.gz: d1d117e611b42497834c3276f08e35e3a70a3b2d0f960ac3d666dde3c12eb32697f911e0af3409e76500977f4c1db835c4979a85879e86bbd00e0ec0df4cc34c
+  data.tar.gz: b3f8f76bc8be51fc23493c1660cb41e5f6b9c10721941bd98c72c49652c807bb320def722cdc3c08d822f2cd2ed0dbe993b75cd6d43d0f1593de6890a753af32

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

@@ -58,7 +58,7 @@ public partial class EntryPointTests
             );
         }
 
-        private static async Task RunAsync(TestFile[] files, Job job, string[] expectedUrls, MockNuGetPackage[]? packages = null)
+        private static async Task RunAsync(TestFile[] files, Job job, string[] expectedUrls, MockNuGetPackage[]? packages = null, string? repoContentsPath = null)
         {
             using var tempDirectory = new TemporaryDirectory();
 
@@ -90,7 +90,7 @@ public partial class EntryPointTests
                 "--job-path",
                 jobPath,
                 "--repo-contents-path",
-                tempDirectory.DirectoryPath,
+                repoContentsPath ?? tempDirectory.DirectoryPath,
                 "--api-url",
                 http.BaseUrl,
                 "--job-id",

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

@@ -1,5 +1,7 @@
 using System.Collections.Immutable;
 
+using Newtonsoft.Json;
+
 using NuGet.Common;
 using NuGet.Configuration;
 using NuGet.Frameworks;
@@ -98,6 +100,11 @@ internal static class VersionFinder
                 // if anything goes wrong here, the package source obviously doesn't contain the requested package
                 continue;
             }
+            catch (JsonReaderException ex)
+            {
+                // unable to parse server response
+                throw new BadResponseException(ex.Message, source.Source);
+            }
 
             var feedVersions = (await feed.GetVersions(
                 packageId,

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/BadResponseException.cs

@@ -0,0 +1,12 @@
+namespace NuGetUpdater.Core;
+
+internal class BadResponseException : Exception
+{
+    public string Uri { get; }
+
+    public BadResponseException(string message, string uri)
+        : base(message)
+    {
+        Uri = uri;
+    }
+}

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

@@ -1,9 +1,11 @@
 using System.Collections.Immutable;
+using System.Text.Json;
 using System.Xml.Linq;
 using System.Xml.XPath;
 
 using Microsoft.Build.Logging.StructuredLogger;
 
+using NuGet.Frameworks;
 using NuGet.Versioning;
 
 using NuGetUpdater.Core.Utilities;
@@ -39,6 +41,8 @@ internal static class SdkProjectDiscovery
     // these packages are resolved during restore, but aren't really updatable and shouldn't be reported as dependencies
     private static readonly HashSet<string> NonReportedPackgeNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
     {
+        "Microsoft.NETCore.Platforms",
+        "Microsoft.NETCore.Targets",
         "NETStandard.Library"
     };
 
@@ -84,6 +88,9 @@ internal static class SdkProjectDiscovery
         Dictionary<string, Dictionary<string, Dictionary<string, string>>> packagesReplacedBySdkPerProject = new(PathComparer.Instance);
         //    projectPath                tfm        packageName  packageVersion
 
+        Dictionary<string, Dictionary<string, HashSet<string>>> packageDependencies = new(PathComparer.Instance);
+        //    projectPath                tfm  packageNames
+
         Dictionary<string, Dictionary<string, string>> resolvedProperties = new(PathComparer.Instance);
         //    projectPath       propertyName  propertyValue
 
@@ -228,6 +235,28 @@ internal static class SdkProjectDiscovery
                                         }
                                     }
                                 }
+
+                                // track all referenced projects in case they have no assemblies and can't be otherwise reported
+                                if (addItem.Name.Equals("PackageDependencies", StringComparison.OrdinalIgnoreCase))
+                                {
+                                    var projectEvaluation = GetNearestProjectEvaluation(node);
+                                    if (projectEvaluation is not null)
+                                    {
+                                        var specificPackageDeps = packageDependencies.GetOrAdd(projectEvaluation.ProjectFile, () => new(StringComparer.OrdinalIgnoreCase));
+                                        var tfm = GetPropertyValueFromProjectEvaluation(projectEvaluation, "TargetFramework");
+                                        if (tfm is not null)
+                                        {
+                                            var packagesByTfm = specificPackageDeps.GetOrAdd(tfm, () => new(StringComparer.OrdinalIgnoreCase));
+                                            foreach (var package in addItem.Children.OfType<Item>())
+                                            {
+                                                if (!NonReportedPackgeNames.Contains(package.Name))
+                                                {
+                                                    packagesByTfm.Add(package.Name);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
                             }
                             break;
                         case Target target when target.Name == "_HandlePackageFileConflicts":
@@ -330,7 +359,7 @@ internal static class SdkProjectDiscovery
         }
 
         // and done
-        var projectDiscoveryResults = BuildResults(
+        var projectDiscoveryResults = await BuildResults(
             repoRootPath,
             workspacePath,
             packagesPerProject,
@@ -338,6 +367,7 @@ internal static class SdkProjectDiscovery
             packagesReplacedBySdkPerProject,
             topLevelPackagesPerProject,
             resolvedProperties,
+            packageDependencies,
             referencedProjects,
             importedFiles,
             additionalFiles
@@ -345,7 +375,7 @@ internal static class SdkProjectDiscovery
         return projectDiscoveryResults;
     }
 
-    private static ImmutableArray<ProjectDiscoveryResult> BuildResults(
+    private static async Task<ImmutableArray<ProjectDiscoveryResult>> BuildResults(
         string repoRootPath,
         string workspacePath,
         Dictionary<string, Dictionary<string, Dictionary<string, string>>> packagesPerProject,
@@ -353,13 +383,14 @@ internal static class SdkProjectDiscovery
         Dictionary<string, Dictionary<string, Dictionary<string, string>>> packagesReplacedBySdkPerProject,
         Dictionary<string, Dictionary<string, HashSet<string>>> topLevelPackagesPerProject,
         Dictionary<string, Dictionary<string, string>> resolvedProperties,
+        Dictionary<string, Dictionary<string, HashSet<string>>> packageDependencies,
         Dictionary<string, HashSet<string>> referencedProjects,
         Dictionary<string, HashSet<string>> importedFiles,
         Dictionary<string, HashSet<string>> additionalFiles
     )
     {
         var projectDiscoveryResults = new List<ProjectDiscoveryResult>();
-        foreach (var projectPath in packagesPerProject.Keys.OrderBy(p => p)) //packagesPerProject.Keys.OrderBy(p => p).Select(projectPath =>
+        foreach (var projectPath in packagesPerProject.Keys.OrderBy(p => p))
         {
             // gather some project-level information
             var packagesByTfm = packagesPerProject[projectPath];
@@ -400,18 +431,99 @@ internal static class SdkProjectDiscovery
                 .SelectMany(kvp => kvp.Value)
                 .ToHashSet(StringComparer.OrdinalIgnoreCase);
 
+            var propertiesForProject = resolvedProperties.GetOrAdd(projectPath, () => new(StringComparer.OrdinalIgnoreCase));
+            var assetsJson = new Lazy<JsonElement?>(() =>
+            {
+                if (propertiesForProject.TryGetValue("ProjectAssetsFile", out var assetsFilePath))
+                {
+                    var assetsContent = File.ReadAllText(assetsFilePath);
+                    var assets = JsonDocument.Parse(assetsContent).RootElement;
+                    return assets;
+                }
+
+                return null;
+            });
+
             // create dependencies
             var tfms = packagesByTfm.Keys.OrderBy(tfm => tfm).ToImmutableArray();
-            var dependencies = tfms.SelectMany(tfm =>
+            var groupedDependencies = new Dictionary<string, Dependency>(StringComparer.OrdinalIgnoreCase);
+            foreach (var tfm in tfms)
             {
-                return packagesByTfm[tfm].Keys.OrderBy(p => p).Select(packageName =>
+                var parsedTfm = NuGetFramework.Parse(tfm);
+                var packages = packagesByTfm[tfm];
+
+                // augment with any packages that might not have reported assemblies
+                var assetsPackageVersions = new Lazy<Dictionary<string, string>>(() =>
+                {
+                    var result = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                    if (assetsJson.Value is { } assets &&
+                        assets.TryGetProperty("targets", out var tfmObjects))
+                    {
+                        foreach (var tfmObject in tfmObjects.EnumerateObject())
+                        {
+                            // TFM might have a RID suffix after a slash that we can't parse
+                            var tfmParts = tfmObject.Name.Split('/');
+                            var reportedTargetFramework = NuGetFramework.Parse(tfmParts[0]);
+                            if (reportedTargetFramework == parsedTfm)
+                            {
+                                foreach (var packageObject in tfmObject.Value.EnumerateObject())
+                                {
+                                    var parts = packageObject.Name.Split('/');
+                                    if (parts.Length == 2)
+                                    {
+                                        var packageName = parts[0];
+                                        var packageVersion = parts[1];
+                                        result[packageName] = packageVersion;
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    return result;
+                });
+                var packageDepsForProject = packageDependencies.GetOrAdd(projectPath, () => new(StringComparer.OrdinalIgnoreCase));
+                var packageDepsForTfm = packageDepsForProject.GetOrAdd(tfm, () => new(StringComparer.OrdinalIgnoreCase));
+                foreach (var packageDepName in packageDepsForTfm)
+                {
+                    if (packages.ContainsKey(packageDepName))
+                    {
+                        // we already know about this
+                        continue;
+                    }
+
+                    // otherwise find the corresponding version through project.assets.json
+                    if (assetsPackageVersions.Value.TryGetValue(packageDepName, out var packageDepVersion))
+                    {
+                        packages[packageDepName] = packageDepVersion;
+                    }
+                }
+
+                foreach (var package in packages)
                 {
-                    var packageVersion = packagesByTfm[tfm][packageName]!;
+                    var packageName = package.Key;
+                    var packageVersion = package.Value;
                     var isTopLevel = topLevelPackageNames.Contains(packageName);
                     var dependencyType = isTopLevel ? DependencyType.PackageReference : DependencyType.Unknown;
-                    return new Dependency(packageName, packageVersion, dependencyType, TargetFrameworks: [tfm], IsDirect: isTopLevel, IsTransitive: !isTopLevel);
-                });
-            }).ToImmutableArray();
+                    var combinedTfms = new HashSet<string>([tfm], StringComparer.OrdinalIgnoreCase);
+                    if (groupedDependencies.TryGetValue(packageName, out var existingDependency) &&
+                        existingDependency.Version == packageVersion &&
+                        existingDependency.Type == dependencyType &&
+                        existingDependency.TargetFrameworks is not null)
+                    {
+                        // same dependency, combine tfms
+                        combinedTfms.AddRange(existingDependency.TargetFrameworks);
+                    }
+
+                    var normalizedTfms = combinedTfms.OrderBy(t => t).ToImmutableArray();
+                    groupedDependencies[package.Key] = new Dependency(packageName, packageVersion, dependencyType, TargetFrameworks: normalizedTfms, IsDirect: isTopLevel, IsTransitive: !isTopLevel);
+                }
+            }
+
+            var dependencies = groupedDependencies.Values
+                .OrderBy(d => d.Name)
+                .ThenBy(d => d.Version)
+                .ToImmutableArray();
 
             // others
             var properties = resolvedProperties[projectPath]

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

@@ -27,6 +27,12 @@ public abstract record JobErrorBase : MessageBase
         report.AppendLine($"Error type: {Type}");
         foreach (var (key, value) in Details)
         {
+            if (this is UnknownError && key == "error-backtrace")
+            {
+                // there's nothing meaningful in this field
+                continue;
+            }
+
             var valueString = value.ToString();
             if (value is IEnumerable<string> strings)
             {
@@ -44,6 +50,7 @@ public abstract record JobErrorBase : MessageBase
         return ex switch
         {
             BadRequirementException badRequirement => new BadRequirement(badRequirement.Message),
+            BadResponseException badResponse => new PrivateSourceBadResponse([badResponse.Uri]),
             DependencyNotFoundException dependencyNotFound => new DependencyNotFound(string.Join(", ", dependencyNotFound.Dependencies)),
             HttpRequestException httpRequest => httpRequest.StatusCode switch
             {

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

@@ -1,13 +1,23 @@
+using System.Text.Json.Serialization;
+
 namespace NuGetUpdater.Core.Run.ApiModel;
 
 public record UnknownError : JobErrorBase
 {
+    [JsonIgnore]
+    public Exception Exception { get; init; }
+
     public UnknownError(Exception ex, string jobId)
         : base("unknown_error")
     {
+        Exception = ex;
+
+        // The following object is parsed by the server and the `error-backtrace` property is expected to be a Ruby
+        // stacktrace.  Since we're not in Ruby we can set an empty string there and append the .NET stacktrace to
+        // the message.
         Details["error-class"] = ex.GetType().Name;
-        Details["error-message"] = ex.Message;
-        Details["error-backtrace"] = ex.StackTrace ?? "<unknown>";
+        Details["error-message"] = ex.ToString();
+        Details["error-backtrace"] = "";
         Details["package-manager"] = "nuget";
         Details["job-id"] = jobId;
     }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/HttpApiHandler.cs

@@ -2,8 +2,6 @@ using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-using NuGetUpdater.Core.Run.ApiModel;
-
 namespace NuGetUpdater.Core.Run;
 
 public class HttpApiHandler : IApiHandler
@@ -25,39 +23,27 @@ public class HttpApiHandler : IApiHandler
         _jobId = jobId;
     }
 
-    public async Task RecordUpdateJobError(JobErrorBase error)
-    {
-        await PostAsJson("record_update_job_error", error);
-    }
-
-    public async Task UpdateDependencyList(UpdatedDependencyList updatedDependencyList)
+    public async Task SendAsync(string endpoint, object body, string method)
     {
-        await PostAsJson("update_dependency_list", updatedDependencyList);
-    }
-
-    public async Task IncrementMetric(IncrementMetric incrementMetric)
-    {
-        await PostAsJson("increment_metric", incrementMetric);
-    }
-
-    public async Task CreatePullRequest(CreatePullRequest createPullRequest)
-    {
-        await PostAsJson("create_pull_request", createPullRequest);
-    }
-
-    public async Task ClosePullRequest(ClosePullRequest closePullRequest)
-    {
-        await PostAsJson("close_pull_request", closePullRequest);
-    }
-
-    public async Task UpdatePullRequest(UpdatePullRequest updatePullRequest)
-    {
-        await PostAsJson("update_pull_request", updatePullRequest);
-    }
+        var uri = $"{_apiUrl}/update_jobs/{_jobId}/{endpoint}";
+        var payload = Serialize(body);
+        var content = new StringContent(payload, Encoding.UTF8, "application/json");
+        var httpMethod = new HttpMethod(method);
+        var message = new HttpRequestMessage(httpMethod, uri)
+        {
+            Content = content
+        };
+        var response = await HttpClient.SendAsync(message);
+        if (!response.IsSuccessStatusCode)
+        {
+            var responseContent = await response.Content.ReadAsStringAsync();
+            if (!string.IsNullOrEmpty(responseContent))
+            {
+                responseContent = string.Concat(": ", responseContent);
+            }
 
-    public async Task MarkAsProcessed(MarkAsProcessed markAsProcessed)
-    {
-        await PatchAsJson("mark_as_processed", markAsProcessed);
+            throw new HttpRequestException(message: $"{(int)response.StatusCode} ({response.StatusCode}){responseContent}", inner: null, statusCode: response.StatusCode);
+        }
     }
 
     internal static string Serialize(object body)
@@ -69,21 +55,4 @@ public class HttpApiHandler : IApiHandler
         var payload = JsonSerializer.Serialize(wrappedBody, SerializerOptions);
         return payload;
     }
-
-    private Task PostAsJson(string endpoint, object body) => SendAsJson(endpoint, body, "POST");
-    private Task PatchAsJson(string endpoint, object body) => SendAsJson(endpoint, body, "PATCH");
-
-    private async Task SendAsJson(string endpoint, object body, string method)
-    {
-        var uri = $"{_apiUrl}/update_jobs/{_jobId}/{endpoint}";
-        var payload = Serialize(body);
-        var content = new StringContent(payload, Encoding.UTF8, "application/json");
-        var httpMethod = new HttpMethod(method);
-        var message = new HttpRequestMessage(httpMethod, uri)
-        {
-            Content = content
-        };
-        var response = await HttpClient.SendAsync(message);
-        var _ = response.EnsureSuccessStatusCode();
-    }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/IApiHandler.cs

@@ -4,11 +4,37 @@ namespace NuGetUpdater.Core.Run;
 
 public interface IApiHandler
 {
-    Task RecordUpdateJobError(JobErrorBase error);
-    Task UpdateDependencyList(UpdatedDependencyList updatedDependencyList);
-    Task IncrementMetric(IncrementMetric incrementMetric);
-    Task CreatePullRequest(CreatePullRequest createPullRequest);
-    Task ClosePullRequest(ClosePullRequest closePullRequest);
-    Task UpdatePullRequest(UpdatePullRequest updatePullRequest);
-    Task MarkAsProcessed(MarkAsProcessed markAsProcessed);
+    Task SendAsync(string endpoint, object body, string method);
+}
+
+public static class IApiHandlerExtensions
+{
+    public static async Task RecordUpdateJobError(this IApiHandler handler, JobErrorBase error)
+    {
+        await handler.PostAsJson("record_update_job_error", error);
+        if (error is UnknownError unknown)
+        {
+            await handler.PostAsJson("record_update_job_unknown_error", error);
+            var increment = new IncrementMetric()
+            {
+                Metric = "updater.update_job_unknown_error",
+                Tags =
+                {
+                    ["package_manager"] = "nuget",
+                    ["class_name"] = unknown.Exception.GetType().Name
+                },
+            };
+            await handler.IncrementMetric(increment);
+        }
+    }
+
+    public static Task UpdateDependencyList(this IApiHandler handler, UpdatedDependencyList updatedDependencyList) => handler.PostAsJson("update_dependency_list", updatedDependencyList);
+    public static Task IncrementMetric(this IApiHandler handler, IncrementMetric incrementMetric) => handler.PostAsJson("increment_metric", incrementMetric);
+    public static Task CreatePullRequest(this IApiHandler handler, CreatePullRequest createPullRequest) => handler.PostAsJson("create_pull_request", createPullRequest);
+    public static Task ClosePullRequest(this IApiHandler handler, ClosePullRequest closePullRequest) => handler.PostAsJson("close_pull_request", closePullRequest);
+    public static Task UpdatePullRequest(this IApiHandler handler, UpdatePullRequest updatePullRequest) => handler.PostAsJson("update_pull_request", updatePullRequest);
+    public static Task MarkAsProcessed(this IApiHandler handler, MarkAsProcessed markAsProcessed) => handler.PatchAsJson("mark_as_processed", markAsProcessed);
+
+    private static Task PostAsJson(this IApiHandler handler, string endpoint, object body) => handler.SendAsync(endpoint, body, "POST");
+    private static Task PatchAsJson(this IApiHandler handler, string endpoint, object body) => handler.SendAsync(endpoint, body, "PATCH");
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/RunWorker.cs

@@ -223,12 +223,17 @@ public class RunWorker
             {
                 if (!job.UpdatingAPullRequest)
                 {
-                    var existingPullRequest = job.GetExistingPullRequestForDependency(analysisResult.UpdatedDependencies.First(d => d.Name.Equals(dependency.Name, StringComparison.OrdinalIgnoreCase)));
-                    if (existingPullRequest is not null)
+                    var updatedDependencyFromAnalysis = analysisResult.UpdatedDependencies
+                        .FirstOrDefault(d => d.Name.Equals(dependency.Name, StringComparison.OrdinalIgnoreCase));
+                    if (updatedDependencyFromAnalysis is not null)
                     {
-                        await SendApiMessage(new PullRequestExistsForLatestVersion(dependency.Name, analysisResult.UpdatedVersion));
-                        unhandledPullRequestDependenciesSet.RemoveWhere(handled => handled.Count == 1 && handled.Contains(dependency.Name));
-                        continue;
+                        var existingPullRequest = job.GetExistingPullRequestForDependency(updatedDependencyFromAnalysis);
+                        if (existingPullRequest is not null)
+                        {
+                            await SendApiMessage(new PullRequestExistsForLatestVersion(dependency.Name, analysisResult.UpdatedVersion));
+                            unhandledPullRequestDependenciesSet.RemoveWhere(handled => handled.Count == 1 && handled.Contains(dependency.Name));
+                            continue;
+                        }
                     }
                 }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/PackageReferenceUpdater.cs

@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using System.Text.Json;
+using System.Text.RegularExpressions;
 
 using Microsoft.Language.Xml;
 
@@ -526,7 +527,7 @@ internal static class PackageReferenceUpdater
     /// <returns>The updated files.</returns>
     private static async Task<IEnumerable<string>> AddTransitiveDependencyAsync(string repoRootPath, string projectPath, string dependencyName, string newDependencyVersion, ExperimentsManager experimentsManager, ILogger logger)
     {
-        var updatedFiles = new[] { projectPath }; // assume this worked unless...
+        var updatedFiles = new List<string>() { projectPath }; // assume this worked unless...
         var projectDirectory = Path.GetDirectoryName(projectPath)!;
         await MSBuildHelper.HandleGlobalJsonAsync(projectDirectory, repoRootPath, experimentsManager, async () =>
         {
@@ -545,6 +546,17 @@ internal static class PackageReferenceUpdater
                 updatedFiles = [];
             }
 
+            // output might contain a line like this:
+            //   info : PackageReference for package 'Some.Package' added to 'C:\project.csproj' and PackageVersion added to central package management file 'C:\Directory.Packages.props'.
+            // we explicitly want to pull out this:                                                                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+            // so we can report all files updated on disk
+            var match = Regex.Match(stdout, @"added to central package management file '(?<CentralPackageManagementFilePath>[^']+)'");
+            if (match.Success)
+            {
+                var cpmFilePath = match.Groups["CentralPackageManagementFilePath"].Value;
+                updatedFiles.Add(cpmFilePath);
+            }
+
             return exitCode;
         }, logger, retainMSBuildSdks: true);
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/MSBuildHelper.cs

@@ -1029,6 +1029,7 @@ internal static partial class MSBuildHelper
             new Regex(@"Unable to find package (?<PackageName>[^ ]+)\. No packages exist with this id in source\(s\): (?<PackageSource>.*)$", RegexOptions.Multiline),
             new Regex(@"Unable to find package (?<PackageName>[^ ]+) with version \((?<PackageVersion>[^)]+)\)"),
             new Regex(@"Could not resolve SDK ""(?<PackageName>[^ ]+)""\."),
+            new Regex(@"Failed to fetch results from V2 feed at '.*FindPackagesById\(\)\?id='(?<PackageName>[^']+)'&semVerLevel=2\.0\.0' with following message : Response status code does not indicate success: 404\."),
         };
         var matches = patterns.Select(p => p.Match(output)).Where(m => m.Success);
         if (matches.Any())

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

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

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

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