dependabot-nuget 0.297.2 → 0.299.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 303dd4ae4de15c33ca64bc0a8957ee6a4fa27cac4ffd2fbb93047d518d6afdb6
-  data.tar.gz: b4075db4bac953819932132e23d6478b6bc3e06242032d79235d2025caa1ed6f
+  metadata.gz: 47471c96a0fec7881b5454528d6cd07199cd600b1ec4dde66656fc754db318fe
+  data.tar.gz: 2364b4e071736115c1cb9503dc40562819e4c376198321761812c70dc309f1bd
 SHA512:
-  metadata.gz: 700973559052453bdfe9d999df2c980d1a5d95ecf296393edb1d1e030c050fa24eafd344898ed3017e2b6a19f7f61cf1503388ec875ffa093fc05b26cbbfc3a5
-  data.tar.gz: 3c3464e7f039d06e3fc55b3406e966767b2ed2e33d31c604f8034c7bde706aea942bcd5499b415ed1d8fae1b19323f57439e82b749e08ba0591aa53cab80aecb
+  metadata.gz: d31e631d9c1dd411843c4c911ad2db4e8a19f4d1fd15ffb0e5c2d4af1b092520bcc4aea2b31996c765870973e0da47b85910fb7d14f81ca973a7069554dc6733
+  data.tar.gz: 48714dea50d6fab935c7ca952e5d992f9aaf0699a54f99f576db55575b36251af0b7503744d229d187245b7e1eab687ce639fad574c8b15bb795f569720a0c99

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

@@ -62,23 +62,24 @@ internal static class VersionFinder
 
         foreach (var source in sources)
         {
-            var sourceRepository = Repository.Factory.GetCoreV3(source);
-            var feed = await sourceRepository.GetResourceAsync<MetadataResource>();
-            if (feed is null)
+            MetadataResource? feed = null;
+            try
             {
-                logger.Warn($"Failed to get {nameof(MetadataResource)} for [{source.Source}]");
-                continue;
-            }
+                var sourceRepository = Repository.Factory.GetCoreV3(source);
+                feed = await sourceRepository.GetResourceAsync<MetadataResource>();
+                if (feed is null)
+                {
+                    logger.Warn($"Failed to get {nameof(MetadataResource)} for [{source.Source}]");
+                    continue;
+                }
 
-            var packageFinder = await sourceRepository.GetResourceAsync<FindPackageByIdResource>();
-            if (packageFinder is null)
-            {
-                logger.Warn($"Failed to get {nameof(FindPackageByIdResource)} for [{source.Source}]");
-                continue;
-            }
+                var packageFinder = await sourceRepository.GetResourceAsync<FindPackageByIdResource>();
+                if (packageFinder is null)
+                {
+                    logger.Warn($"Failed to get {nameof(FindPackageByIdResource)} for [{source.Source}]");
+                    continue;
+                }
 
-            try
-            {
                 // a non-compliant v2 API returning 404 can cause this to throw
                 var existsInFeed = await feed.Exists(
                     packageId,

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/FrameworkChecker/SupportedFrameworks.cs

@@ -20,7 +20,8 @@ namespace NuGetGallery.Frameworks
     /// </remarks>
     public static class SupportedFrameworks
     {
-        public static readonly Version Version8 = new Version(8, 0, 0, 0); // https://github.com/NuGet/Engineering/issues/5112
+        public static readonly Version Version8 = new Version(8, 0, 0, 0);
+        public static readonly Version Version9 = new Version(9, 0, 0, 0);
 
         public static readonly NuGetFramework MonoAndroid = new NuGetFramework(FrameworkIdentifiers.MonoAndroid, EmptyVersion);
         public static readonly NuGetFramework MonoTouch = new NuGetFramework(FrameworkIdentifiers.MonoTouch, EmptyVersion);
@@ -29,12 +30,14 @@ namespace NuGetGallery.Frameworks
         public static readonly NuGetFramework Net48 = new NuGetFramework(FrameworkIdentifiers.Net, new Version(4, 8, 0, 0));
         public static readonly NuGetFramework Net481 = new NuGetFramework(FrameworkIdentifiers.Net, new Version(4, 8, 1, 0));
         public static readonly NuGetFramework Net50Windows = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version5, "windows", EmptyVersion);
+
         public static readonly NuGetFramework Net60Android = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "android", EmptyVersion);
         public static readonly NuGetFramework Net60Ios = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "ios", EmptyVersion);
         public static readonly NuGetFramework Net60MacOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "macos", EmptyVersion);
         public static readonly NuGetFramework Net60MacCatalyst = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "maccatalyst", EmptyVersion);
         public static readonly NuGetFramework Net60TvOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "tvos", EmptyVersion);
         public static readonly NuGetFramework Net60Windows = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "windows", EmptyVersion);
+
         public static readonly NuGetFramework Net70Android = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "android", EmptyVersion);
         public static readonly NuGetFramework Net70Ios = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "ios", EmptyVersion);
         public static readonly NuGetFramework Net70MacOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "macos", EmptyVersion);
@@ -42,14 +45,22 @@ namespace NuGetGallery.Frameworks
         public static readonly NuGetFramework Net70TvOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "tvos", EmptyVersion);
         public static readonly NuGetFramework Net70Windows = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "windows", EmptyVersion);
 
-        public static readonly NuGetFramework Net80 = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8); // https://github.com/NuGet/Engineering/issues/5112
-
+        public static readonly NuGetFramework Net80 = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8);
         public static readonly NuGetFramework Net80Android = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "android", EmptyVersion);
         public static readonly NuGetFramework Net80Ios = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "ios", EmptyVersion);
         public static readonly NuGetFramework Net80MacOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "macos", EmptyVersion);
         public static readonly NuGetFramework Net80MacCatalyst = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "maccatalyst", EmptyVersion);
         public static readonly NuGetFramework Net80TvOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "tvos", EmptyVersion);
         public static readonly NuGetFramework Net80Windows = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "windows", EmptyVersion);
+
+        public static readonly NuGetFramework Net90 = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version9);
+        public static readonly NuGetFramework Net90Android = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version9, "android", EmptyVersion);
+        public static readonly NuGetFramework Net90Ios = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version9, "ios", EmptyVersion);
+        public static readonly NuGetFramework Net90MacOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version9, "macos", EmptyVersion);
+        public static readonly NuGetFramework Net90MacCatalyst = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version9, "maccatalyst", EmptyVersion);
+        public static readonly NuGetFramework Net90TvOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version9, "tvos", EmptyVersion);
+        public static readonly NuGetFramework Net90Windows = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version9, "windows", EmptyVersion);
+
         public static readonly NuGetFramework NetCore = new NuGetFramework(FrameworkIdentifiers.NetCore, EmptyVersion);
         public static readonly NuGetFramework NetMf = new NuGetFramework(FrameworkIdentifiers.NetMicro, EmptyVersion);
         public static readonly NuGetFramework UAP = new NuGetFramework(FrameworkIdentifiers.UAP, EmptyVersion);
@@ -75,6 +86,7 @@ namespace NuGetGallery.Frameworks
                 Net60, Net60Android, Net60Ios, Net60MacCatalyst, Net60MacOs, Net60TvOs, Net60Windows,
                 Net70, Net70Android, Net70Ios, Net70MacCatalyst, Net70MacOs, Net70TvOs, Net70Windows,
                 Net80, Net80Android, Net80Ios, Net80MacCatalyst, Net80MacOs, Net80TvOs, Net80Windows,
+                Net90, Net90Android, Net90Ios, Net90MacCatalyst, Net90MacOs, Net90TvOs, Net90Windows,
                 NetCore, NetCore45, NetCore451,
                 NetCoreApp10, NetCoreApp11, NetCoreApp20, NetCoreApp21, NetCoreApp22, NetCoreApp30, NetCoreApp31,
                 NetMf,
@@ -94,6 +106,7 @@ namespace NuGetGallery.Frameworks
         {
             public static readonly List<NuGetFramework> NetTfms =
             [
+                Net90,
                 Net80,
                 Net70,
                 Net60,

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

@@ -3,6 +3,7 @@ using System.Net;
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using System.Text.RegularExpressions;
 
 using Microsoft.Extensions.FileSystemGlobbing;
 
@@ -13,6 +14,8 @@ using NuGetUpdater.Core.Discover;
 using NuGetUpdater.Core.Run.ApiModel;
 using NuGetUpdater.Core.Utilities;
 
+using static NuGetUpdater.Core.Utilities.EOLHandling;
+
 namespace NuGetUpdater.Core.Run;
 
 public class RunWorker
@@ -122,6 +125,7 @@ public class RunWorker
 
         // TODO: pull out relevant dependencies, then check each for updates and track the changes
         var originalDependencyFileContents = new Dictionary<string, string>();
+        var originalDependencyFileEOFs = new Dictionary<string, EOLType>();
         var actualUpdatedDependencies = new List<ReportedDependency>();
 
         // track original contents for later handling
@@ -131,6 +135,7 @@ public class RunWorker
             var localFullPath = Path.Join(repoContentsPath.FullName, repoFullPath);
             var content = await File.ReadAllTextAsync(localFullPath);
             originalDependencyFileContents[repoFullPath] = content;
+            originalDependencyFileEOFs[repoFullPath] = content.GetPredominantEOL();
         }
 
         foreach (var project in discoveryResult.Projects)
@@ -142,20 +147,43 @@ public class RunWorker
                 var extraFilePath = Path.Join(projectDirectory, extraFile);
                 await TrackOriginalContentsAsync(discoveryResult.Path, extraFilePath);
             }
-            // TODO: include global.json, etc.
+        }
+
+        var nonProjectFiles = new[]
+        {
+            discoveryResult.GlobalJson?.FilePath,
+            discoveryResult.DotNetToolsJson?.FilePath,
+        }.Where(f => f is not null).Cast<string>().ToArray();
+        foreach (var nonProjectFile in nonProjectFiles)
+        {
+            await TrackOriginalContentsAsync(discoveryResult.Path, nonProjectFile);
         }
 
         // do update
         var updateOperations = GetUpdateOperations(discoveryResult).ToArray();
-        foreach (var updateOperation in updateOperations)
+        var allowedUpdateOperations = updateOperations.Where(u => IsUpdateAllowed(job, u.Dependency)).ToArray();
+
+        // requested update isn't listed => SecurityUpdateNotNeeded
+        var expectedSecurityUpdateDependencyNames = job.SecurityAdvisories
+            .Select(s => s.DependencyName)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+        var actualUpdateDependencyNames = allowedUpdateOperations
+            .Select(u => u.Dependency.Name)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+        var expectedDependencyUpdateMissingInActual = expectedSecurityUpdateDependencyNames
+            .Except(actualUpdateDependencyNames, StringComparer.OrdinalIgnoreCase)
+            .OrderBy(d => d, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+
+        foreach (var missingSecurityUpdate in expectedDependencyUpdateMissingInActual)
         {
-            var dependency = updateOperation.Dependency;
-            if (!IsUpdateAllowed(job, dependency))
-            {
-                continue;
-            }
+            await _apiHandler.RecordUpdateJobError(new SecurityUpdateNotNeeded(missingSecurityUpdate));
+        }
 
-            _logger.Info($"Updating [{dependency.Name}] in [{updateOperation.ProjectPath}]");
+        foreach (var updateOperation in allowedUpdateOperations)
+        {
+            var dependency = updateOperation.Dependency;
+            _logger.Info($"Updating [{dependency.Name}] in [{updateOperation.FilePath}]");
 
             var dependencyInfo = GetDependencyInfo(job, dependency);
             var analysisResult = await _analyzeWorker.RunAsync(repoContentsPath.FullName, discoveryResult, dependencyInfo);
@@ -164,7 +192,7 @@ public class RunWorker
             {
                 // TODO: this is inefficient, but not likely causing a bottleneck
                 var previousDependency = discoveredUpdatedDependencies.Dependencies
-                    .Single(d => d.Name == dependency.Name && d.Requirements.Single().File == updateOperation.ProjectPath);
+                    .Single(d => d.Name == dependency.Name && d.Requirements.Single().File == updateOperation.FilePath);
                 var updatedDependency = new ReportedDependency()
                 {
                     Name = dependency.Name,
@@ -173,7 +201,7 @@ public class RunWorker
                     [
                         new ReportedRequirement()
                         {
-                            File = updateOperation.ProjectPath,
+                            File = updateOperation.FilePath,
                             Requirement = analysisResult.UpdatedVersion,
                             Groups = previousDependency.Requirements.Single().Groups,
                             Source = new RequirementSource()
@@ -186,7 +214,7 @@ public class RunWorker
                     PreviousRequirements = previousDependency.Requirements,
                 };
 
-                var updateResult = await _updaterWorker.RunAsync(repoContentsPath.FullName, updateOperation.ProjectPath, dependency.Name, dependency.Version!, analysisResult.UpdatedVersion, isTransitive: dependency.IsTransitive);
+                var updateResult = await _updaterWorker.RunAsync(repoContentsPath.FullName, updateOperation.FilePath, dependency.Name, dependency.Version!, analysisResult.UpdatedVersion, isTransitive: dependency.IsTransitive);
                 // TODO: need to report if anything was actually updated
                 if (updateResult.Error is null)
                 {
@@ -203,6 +231,10 @@ public class RunWorker
             var localFullPath = Path.GetFullPath(Path.Join(repoContentsPath.FullName, repoFullPath));
             var originalContent = originalDependencyFileContents[repoFullPath];
             var updatedContent = await File.ReadAllTextAsync(localFullPath);
+
+            updatedContent = updatedContent.SetEOL(originalDependencyFileEOFs[repoFullPath]);
+            await File.WriteAllTextAsync(localFullPath, updatedContent);
+
             if (updatedContent != originalContent)
             {
                 updatedDependencyFiles[localFullPath] = new DependencyFile()
@@ -223,7 +255,11 @@ public class RunWorker
                 var extraFilePath = Path.Join(projectDirectory, extraFile);
                 await AddUpdatedFileIfDifferentAsync(discoveryResult.Path, extraFilePath);
             }
-            // TODO: handle global.json, etc.
+        }
+
+        foreach (var nonProjectFile in nonProjectFiles)
+        {
+            await AddUpdatedFileIfDifferentAsync(discoveryResult.Path, nonProjectFile);
         }
 
         if (updatedDependencyFiles.Count > 0)
@@ -266,34 +302,50 @@ public class RunWorker
         return result;
     }
 
-    internal static IEnumerable<(string ProjectPath, Dependency Dependency)> GetUpdateOperations(WorkspaceDiscoveryResult discovery)
+    internal static IEnumerable<(string FilePath, Dependency Dependency)> GetUpdateOperations(WorkspaceDiscoveryResult discovery)
     {
-        // discovery is grouped by project then dependency, but we want to pivot and return a list of update operations sorted by dependency name then project path
+        // discovery is grouped by project/file then dependency, but we want to pivot and return a list of update operations sorted by dependency name then file path
 
         var updateOrder = new Dictionary<string, Dictionary<string, Dictionary<string, Dependency>>>(StringComparer.OrdinalIgnoreCase);
-        //                     <dependency name,     <project path, specific dependencies>>
+        //                     <dependency name,        <file path, specific dependencies>>
 
         // collect
-        foreach (var project in discovery.Projects)
+        void CollectDependenciesForFile(string filePath, IEnumerable<Dependency> dependencies)
         {
-            var projectPath = Path.Join(discovery.Path, project.FilePath).FullyNormalizedRootedPath();
-            foreach (var dependency in project.Dependencies)
+            foreach (var dependency in dependencies)
             {
                 var dependencyGroup = updateOrder.GetOrAdd(dependency.Name, () => new Dictionary<string, Dictionary<string, Dependency>>(PathComparer.Instance));
-                var dependenciesForProject = dependencyGroup.GetOrAdd(projectPath, () => new Dictionary<string, Dependency>(StringComparer.OrdinalIgnoreCase));
-                dependenciesForProject[dependency.Name] = dependency;
+                var dependenciesForFile = dependencyGroup.GetOrAdd(filePath, () => new Dictionary<string, Dependency>(StringComparer.OrdinalIgnoreCase));
+                dependenciesForFile[dependency.Name] = dependency;
             }
         }
+        foreach (var project in discovery.Projects)
+        {
+            var projectPath = Path.Join(discovery.Path, project.FilePath).FullyNormalizedRootedPath();
+            CollectDependenciesForFile(projectPath, project.Dependencies);
+        }
+
+        if (discovery.GlobalJson is not null)
+        {
+            var globalJsonPath = Path.Join(discovery.Path, discovery.GlobalJson.FilePath).FullyNormalizedRootedPath();
+            CollectDependenciesForFile(globalJsonPath, discovery.GlobalJson.Dependencies);
+        }
+
+        if (discovery.DotNetToolsJson is not null)
+        {
+            var dotnetToolsJsonPath = Path.Join(discovery.Path, discovery.DotNetToolsJson.FilePath).FullyNormalizedRootedPath();
+            CollectDependenciesForFile(dotnetToolsJsonPath, discovery.DotNetToolsJson.Dependencies);
+        }
 
         // return
         foreach (var dependencyName in updateOrder.Keys.OrderBy(k => k, StringComparer.OrdinalIgnoreCase))
         {
-            var projectDependencies = updateOrder[dependencyName];
-            foreach (var projectPath in projectDependencies.Keys.OrderBy(p => p, PathComparer.Instance))
+            var fileDependencies = updateOrder[dependencyName];
+            foreach (var filePath in fileDependencies.Keys.OrderBy(p => p, PathComparer.Instance))
             {
-                var dependencies = projectDependencies[projectPath];
+                var dependencies = fileDependencies[filePath];
                 var dependency = dependencies[dependencyName];
-                yield return (projectPath, dependency);
+                yield return (filePath, dependency);
             }
         }
     }
@@ -440,35 +492,69 @@ public class RunWorker
             }
         }
 
+        var allDependenciesWithFilePath = discoveryResult.Projects.SelectMany(p =>
+        {
+            return p.Dependencies
+                .Where(d => d.Version is not null)
+                .Select(d =>
+                    (p.FilePath, new ReportedDependency()
+                    {
+                        Name = d.Name,
+                        Requirements = [new ReportedRequirement()
+                            {
+                                File = GetFullRepoPath(p.FilePath),
+                                Requirement = d.Version!,
+                                Groups = ["dependencies"],
+                            }],
+                        Version = d.Version,
+                    }));
+        }).ToList();
+
+        var nonProjectDependencySet = new (string?, IEnumerable<Dependency>)[]
+        {
+            (discoveryResult.GlobalJson?.FilePath, discoveryResult.GlobalJson?.Dependencies ?? []),
+            (discoveryResult.DotNetToolsJson?.FilePath, discoveryResult.DotNetToolsJson?.Dependencies ?? []),
+        };
+
+        foreach (var (filePath, dependencies) in nonProjectDependencySet)
+        {
+            if (filePath is null)
+            {
+                continue;
+            }
+
+            allDependenciesWithFilePath.AddRange(dependencies
+                .Where(d => d.Version is not null)
+                .Select(d =>
+                    (filePath, new ReportedDependency()
+                    {
+                        Name = d.Name,
+                        Requirements = [new ReportedRequirement()
+                            {
+                                File = GetFullRepoPath(filePath),
+                                Requirement = d.Version!,
+                                Groups = ["dependencies"],
+                            }],
+                        Version = d.Version,
+                    })));
+        }
+
+        var sortedDependencies = allDependenciesWithFilePath
+            .OrderBy(pair => Path.Join(discoveryResult.Path, pair.FilePath).FullyNormalizedRootedPath(), PathComparer.Instance)
+            .ThenBy(pair => pair.Item2.Name, StringComparer.OrdinalIgnoreCase)
+            .Select(pair => pair.Item2)
+            .ToArray();
+
         var dependencyFiles = discoveryResult.Projects
             .Select(p => GetFullRepoPath(p.FilePath))
             .Concat(auxiliaryFiles)
             .Distinct()
             .OrderBy(p => p)
             .ToArray();
-        var orderedProjects = discoveryResult.Projects
-            .OrderBy(p => Path.Join(discoveryResult.Path, p.FilePath).FullyNormalizedRootedPath(), PathComparer.Instance)
-            .ToArray();
+
         var updatedDependencyList = new UpdatedDependencyList()
         {
-            Dependencies = orderedProjects.SelectMany(p =>
-            {
-                return p.Dependencies
-                    .Where(d => d.Version is not null)
-                    .OrderBy(d => d.Name, StringComparer.OrdinalIgnoreCase)
-                    .Select(d =>
-                        new ReportedDependency()
-                        {
-                            Name = d.Name,
-                            Requirements = [new ReportedRequirement()
-                            {
-                                File = GetFullRepoPath(p.FilePath),
-                                Requirement = d.Version!,
-                                Groups = ["dependencies"],
-                            }],
-                            Version = d.Version,
-                        });
-            }).ToArray(),
+            Dependencies = sortedDependencies,
             DependencyFiles = dependencyFiles,
         };
         return updatedDependencyList;

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

@@ -0,0 +1,78 @@
+using System.Text.RegularExpressions;
+
+namespace NuGetUpdater.Core.Utilities;
+
+public static class EOLHandling
+{
+    /// <summary>
+    /// Used to save (and then restore) which line endings are predominant in a file.
+    /// </summary>
+    public enum EOLType
+    {
+        /// <summary>
+        /// Line feed - \n
+        /// Typical on most systems.
+        /// </summary>
+        LF,
+        /// <summary>
+        /// Carriage return - \r
+        /// Typical on older MacOS, unlikely (but possible) to come up here
+        /// </summary>
+        CR,
+        /// <summary>
+        /// Carriage return and line feed - \r\n.
+        /// Typical on Windows
+        /// </summary>
+        CRLF
+    };
+
+    /// <summary>
+    /// Analyze the input string and find the most common line ending type.
+    /// </summary>
+    /// <param name="content">The string to analyze</param>
+    /// <returns>The most common type of line ending in the input string.</returns>
+    public static EOLType GetPredominantEOL(this string content)
+    {
+        // Get stats on EOL characters/character sequences, if one predominates choose that for writing later.
+        var lfcount = content.Count(c => c == '\n');
+        var crcount = content.Count(c => c == '\r');
+        var crlfcount = Regex.Matches(content, "\r\n").Count();
+
+        // Since CRLF contains both a CR and a LF, subtract it from those counts
+        lfcount -= crlfcount;
+        crcount -= crlfcount;
+        if (crcount > lfcount && crcount > crlfcount)
+        {
+            return EOLType.CR;
+        }
+        else if (crlfcount > lfcount)
+        {
+            return EOLType.CRLF;
+        }
+        else
+        {
+            return EOLType.LF;
+        }
+    }
+
+    /// <summary>
+    /// Given a line ending, modify the input string to uniformly use that line ending.
+    /// </summary>
+    /// <param name="content">The input string, which may have any combination of line endings.</param>
+    /// <param name="desiredEOL">The line ending type to use across the result.</param>
+    /// <returns>The string with any line endings swapped to the desired type.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">If EOLType is an unexpected value.</exception>
+    public static string SetEOL(this string content, EOLType desiredEOL)
+    {
+        switch (desiredEOL)
+        {
+            case EOLType.LF:
+                return Regex.Replace(content, "(\r\n|\r)", "\n");
+            case EOLType.CR:
+                return Regex.Replace(content, "(\r\n|\n)", "\r");
+            case EOLType.CRLF:
+                return Regex.Replace(content, "(\r\n|\r|\n)", "\r\n");
+        }
+        throw new ArgumentOutOfRangeException(nameof(desiredEOL));
+    }
+}

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

@@ -795,7 +795,7 @@ internal static partial class MSBuildHelper
             );
             return (exitCode, stdOut, stdErr);
         });
-        ThrowOnUnauthenticatedFeed(stdOut);
+        ThrowOnError(stdOut);
         if (exitCode != 0)
         {
             logger.Warn($"Error determining target frameworks.\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}");
@@ -975,6 +975,7 @@ internal static partial class MSBuildHelper
             new Regex(@"Package '(?<PackageName>[^']*)' is not found on source '(?<PackageSource>[^$\r\n]*)'\."),
             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>[^ ]+)""\."),
         };
         var matches = patterns.Select(p => p.Match(output)).Where(m => m.Success);
         if (matches.Any())

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

@@ -1300,6 +1300,56 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
         );
     }
 
+    [Fact]
+    public async Task NuGetSourceDoesNotExist()
+    {
+        // this test simulates a `NuGet.Config` that points to an internal-only domain that dependabot doesn't have access to
+        await TestAnalyzeAsync(
+            extraFiles: [
+                ("NuGet.Config", """
+                    <configuration>
+                      <packageSources>
+                        <clear />
+                        <add key="feed_that_does_not_exist" value="https://this-domain-does-not-exist/nuget/v2" />
+                      </packageSources>
+                    </configuration>
+                    """)
+            ],
+            discovery: new()
+            {
+                Path = "/",
+                Projects = [
+                    new()
+                    {
+                        FilePath = "./project.csproj",
+                        TargetFrameworks = ["net9.0"],
+                        Dependencies = [
+                            new("Some.Package", "1.0.0", DependencyType.PackageReference),
+                        ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
+                    }
+                ]
+            },
+            dependencyInfo: new()
+            {
+                Name = "Some.Package",
+                Version = "1.0.0",
+                IgnoredVersions = [],
+                IsVulnerable = false,
+                Vulnerabilities = [],
+            },
+            expectedResult: new()
+            {
+                CanUpdate = false,
+                UpdatedVersion = "1.0.0",
+                VersionComesFromMultiDependencyProperty = false,
+                UpdatedDependencies = [],
+            }
+        );
+    }
+
     [Fact]
     public void DeserializeDependencyInfo_UnsupportedIgnoredVersionsAreIgnored()
     {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Discover/DiscoveryWorkerTests.cs

@@ -1355,4 +1355,30 @@ public partial class DiscoveryWorkerTests : DiscoveryWorkerTestBase
             }
         );
     }
+
+    [Fact]
+    public async Task MissingFileIsReported()
+    {
+        await TestDiscoveryAsync(
+            packages: [],
+            experimentsManager: new ExperimentsManager() { UseDirectDiscovery = true, InstallDotnetSdks = true },
+            workspacePath: "",
+            files: [
+                ("project.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <Import Project="file-that-does-not-exist.props" />
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                    </Project>
+                    """)
+            ],
+            expectedResult: new()
+            {
+                Path = "",
+                Projects = [],
+                ErrorRegex = @"file-that-does-not-exist\.props",
+            }
+        );
+    }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/FrameworkChecker/CompatibilityCheckerFacts.cs

@@ -7,6 +7,8 @@ namespace NuGetUpdater.Core.Test.FrameworkChecker;
 public class CompatibilityCheckerFacts
 {
     [Theory]
+    [InlineData("net9.0", "net9.0")]
+    [InlineData("net9.0", "net8.0")]
     [InlineData("net8.0", "net8.0")]
     [InlineData("net8.0", "net7.0")]
     [InlineData("net7.0", "net7.0")]

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Run/MiscellaneousTests.cs

@@ -58,7 +58,7 @@ public class MiscellaneousTests
     public void GetUpdateOperations(WorkspaceDiscoveryResult discovery, (string ProjectPath, string DependencyName)[] expectedUpdateOperations)
     {
         var updateOperations = RunWorker.GetUpdateOperations(discovery).ToArray();
-        var actualUpdateOperations = updateOperations.Select(uo => (uo.ProjectPath, uo.Dependency.Name)).ToArray();
+        var actualUpdateOperations = updateOperations.Select(uo => (uo.FilePath, uo.Dependency.Name)).ToArray();
         Assert.Equal(expectedUpdateOperations, actualUpdateOperations);
     }
 
@@ -94,6 +94,34 @@ public class MiscellaneousTests
                 ("/src/Common.csproj", "Package.D"),
             },
         ];
+
+        yield return
+        [
+            new WorkspaceDiscoveryResult()
+            {
+                Path = "",
+                Projects = [],
+                GlobalJson = new()
+                {
+                    FilePath = "global.json",
+                    Dependencies = [
+                        new("Some.MSBuild.Sdk", "1.0.0", DependencyType.MSBuildSdk)
+                    ]
+                },
+                DotNetToolsJson = new()
+                {
+                    FilePath = ".config/dotnet-tools.json",
+                    Dependencies = [
+                        new("some-tool", "2.0.0", DependencyType.DotNetTool)
+                    ]
+                }
+            },
+            new (string, string)[]
+            {
+                ("/.config/dotnet-tools.json", "some-tool"),
+                ("/global.json", "Some.MSBuild.Sdk"),
+            }
+        ];
     }
 
     public static IEnumerable<object?[]> RequirementsFromIgnoredVersionsData()