dependabot-nuget 0.254.0 → 0.255.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c86cede5ca7a7c4b299c2ec8562eedac9a80f12b3d3087be4270b37f21a41861
-  data.tar.gz: 8ea3c1c970f4606fed97261c70ebd493645037bdd635ab4368e38956ab1d17f9
+  metadata.gz: 1feb135ca2ebd58b0c7c96df96c8e3ad30b9f0dccd17b58c99d5670fb3ebf57b
+  data.tar.gz: 55e7d7d46b36738f198057ef6c83ea3f194d25623a65d6e719bf1fc5a6f44eb5
 SHA512:
-  metadata.gz: 26ee476b689434e34f322153afc7f825e15555bf7c7061014e4b58bdb5962699226942ac64797d436d38b5aed780d4e57d818bd7ef64f6ed6e1961984129139e
-  data.tar.gz: 28e0103dbcb88c4fabb9352a51891f0f69a0533959c7fe052c8b3396c00fcabfe33ae1d3cb28347ffc44f01464c8517397a11783c0c88a66e4bd04fd9f5b37e3
+  metadata.gz: 13a3eae5d94249eba9a08cbe55c4c36ca3116881550e76a518e789bc7fe7e8ee6d13fcf910a25de365a2e00af96ce586a7f169a52cc1a6b2fc5fbd594d4b8ba5
+  data.tar.gz: 318e0d0cb22917a6198cd0c0821dba4a2456c23a4378f9387d645c205886cac7078119983772806313427e3ceaf52ec72f64f11f134ddb010b2e59e0bf8a2a36

data/helpers/lib/NuGetUpdater/NuGetProjects/NuGet.Packaging/NuGet.Packaging.csproj

@@ -19,6 +19,11 @@
 
   <ItemGroup>
     <Compile Include="$(NuGetSourceLocation)\src\NuGet.Core\NuGet.Packaging\**\*.cs" />
+    <!--
+    The `PackageFolderReader.GetFiles()` method is case-sensitive which doesn't work for some scenarios so this
+    directory contains a copy of that file with that method with a case-insensitive patch.
+    -->
+    <Compile Remove="$(NuGetSourceLocation)\src\NuGet.Core\NuGet.Packaging\PackageFolderReader.cs" />
   </ItemGroup>
 
   <ItemGroup>

data/helpers/lib/NuGetUpdater/NuGetProjects/NuGet.Packaging/PackageFolderReader.cs

@@ -0,0 +1,270 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using NuGet.Common;
+using NuGet.Frameworks;
+using NuGet.Packaging.Core;
+using NuGet.Packaging.Signing;
+
+namespace NuGet.Packaging
+{
+    /// <summary>
+    /// Reads an unzipped nupkg folder.
+    /// </summary>
+    public class PackageFolderReader : PackageReaderBase
+    {
+        private readonly DirectoryInfo _root;
+
+        /// <summary>
+        /// Package folder reader
+        /// </summary>
+        public PackageFolderReader(string folderPath)
+            : this(folderPath, DefaultFrameworkNameProvider.Instance, DefaultCompatibilityProvider.Instance)
+        {
+        }
+
+        /// <summary>
+        /// Package folder reader
+        /// </summary>
+        /// <param name="folder">root directory of an extracted nupkg</param>
+        public PackageFolderReader(DirectoryInfo folder)
+            : this(folder, DefaultFrameworkNameProvider.Instance, DefaultCompatibilityProvider.Instance)
+        {
+        }
+
+        /// <summary>
+        /// Package folder reader
+        /// </summary>
+        /// <param name="folderPath">root directory of an extracted nupkg</param>
+        /// <param name="frameworkProvider">framework mappings</param>
+        /// <param name="compatibilityProvider">framework compatibility provider</param>
+        public PackageFolderReader(string folderPath, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
+            : this(new DirectoryInfo(folderPath), frameworkProvider, compatibilityProvider)
+        {
+        }
+
+        /// <summary>
+        /// Package folder reader
+        /// </summary>
+        /// <param name="folder">root directory of an extracted nupkg</param>
+        /// <param name="frameworkProvider">framework mappings</param>
+        /// <param name="compatibilityProvider">framework compatibility provider</param>
+        public PackageFolderReader(DirectoryInfo folder, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
+            : base(frameworkProvider, compatibilityProvider)
+        {
+            _root = folder;
+        }
+
+        public override string GetNuspecFile()
+        {
+            // This needs to be explicitly case insensitive in order to work on XPlat, since GetFiles is normally case sensitive on non-Windows
+            var nuspecFiles = _root.GetFiles("*.*", SearchOption.TopDirectoryOnly).Where(f => f.Name.EndsWith(".nuspec", StringComparison.OrdinalIgnoreCase)).ToArray();
+
+            if (nuspecFiles.Length == 0)
+            {
+                var message = new StringBuilder();
+                message.Append(Strings.Error_MissingNuspecFile);
+                message.AppendFormat(CultureInfo.CurrentCulture, Strings.Message_Path, _root.FullName);
+                throw new PackagingException(NuGetLogCode.NU5037, message.ToString());
+            }
+            else if (nuspecFiles.Length > 1)
+            {
+                throw new PackagingException(Strings.MultipleNuspecFiles);
+            }
+
+            return nuspecFiles[0].FullName;
+        }
+
+        /// <summary>
+        /// Opens a local file in read only mode.
+        /// </summary>
+        public override Stream GetStream(string path)
+        {
+            return GetFile(path).OpenRead();
+        }
+
+        private FileInfo GetFile(string path)
+        {
+            var file = new FileInfo(Path.Combine(_root.FullName, path));
+
+            if (!file.FullName.StartsWith(_root.FullName, StringComparison.OrdinalIgnoreCase))
+            {
+                // the given path does not appear under the folder root
+                throw new FileNotFoundException(path);
+            }
+
+            return file;
+        }
+
+        public override IEnumerable<string> GetFiles()
+        {
+            // Read all files starting at the root.
+            return GetFiles(folder: null);
+        }
+
+        public override IEnumerable<string> GetFiles(string folder)
+        {
+            // Default to retrieve files and throwing if the root
+            // directory is not found.
+            var getFiles = true;
+            var searchFolder = new DirectoryInfo(_root.FullName);
+
+            if (!string.IsNullOrEmpty(folder))
+            {
+                // Search in the sub folder if one was specified
+                searchFolder = new DirectoryInfo(Path.Combine(_root.FullName, folder));
+
+                // For sub folders verify it exists
+                // The root is expected to exist and should throw if it does not
+                getFiles = searchFolder.Exists;
+
+                // try a case-insensitive search
+                if (!getFiles)
+                {
+                    searchFolder = _root.GetDirectories().FirstOrDefault(d => d.Name.Equals(folder, StringComparison.OrdinalIgnoreCase));
+                    getFiles = searchFolder?.Exists == true;
+                }
+            }
+
+            if (getFiles)
+            {
+                // Enumerate root folder filtering out nupkg files
+                foreach (var file in searchFolder.GetFiles("*", SearchOption.AllDirectories))
+                {
+                    var path = GetRelativePath(_root, file);
+
+                    // disallow nupkgs in the root
+                    if (!IsFileInRoot(path) || !IsNupkg(path))
+                    {
+                        yield return path;
+                    }
+                }
+            }
+
+            yield break;
+        }
+
+        /// <summary>
+        /// True if the path does not contain /
+        /// </summary>
+        private static bool IsFileInRoot(string path)
+        {
+#if NETCOREAPP
+            return path.IndexOf('/', StringComparison.Ordinal) == -1;
+#else
+            return path.IndexOf('/') == -1;
+#endif
+        }
+
+        /// <summary>
+        /// True if the path ends with .nupkg
+        /// </summary>
+        private static bool IsNupkg(string path)
+        {
+            return path.EndsWith(PackagingCoreConstants.NupkgExtension, StringComparison.OrdinalIgnoreCase) == true;
+        }
+
+        /// <summary>
+        /// Build the relative path in the same format that ZipArchive uses
+        /// </summary>
+        private static string GetRelativePath(DirectoryInfo root, FileInfo file)
+        {
+            var parents = new Stack<DirectoryInfo>();
+
+            var parent = file.Directory;
+
+            while (parent != null
+                   && !StringComparer.OrdinalIgnoreCase.Equals(parent.FullName, root.FullName))
+            {
+                parents.Push(parent);
+                parent = parent.Parent;
+            }
+
+            if (parent == null)
+            {
+                // the given file path does not appear under root
+                throw new FileNotFoundException(file.FullName);
+            }
+
+            var parts = parents.Select(d => d.Name).Concat(new string[] { file.Name });
+
+            return string.Join("/", parts);
+        }
+
+        public override IEnumerable<string> CopyFiles(
+            string destination,
+            IEnumerable<string> packageFiles,
+            ExtractPackageFileDelegate extractFile,
+            ILogger logger,
+            CancellationToken token)
+        {
+            var filesCopied = new List<string>();
+
+            foreach (var packageFile in packageFiles)
+            {
+                token.ThrowIfCancellationRequested();
+
+                var sourceFile = GetFile(packageFile);
+
+                var targetPath = Path.Combine(destination, packageFile);
+                Directory.CreateDirectory(Path.GetDirectoryName(targetPath));
+
+                using (var fileStream = sourceFile.OpenRead())
+                {
+                    targetPath = extractFile(sourceFile.FullName, targetPath, fileStream);
+                    if (targetPath != null)
+                    {
+                        ZipArchiveExtensions.UpdateFileTime(targetPath, sourceFile.LastWriteTimeUtc);
+                        filesCopied.Add(targetPath);
+                    }
+                }
+            }
+
+            return filesCopied;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            // do nothing here
+        }
+
+        public override Task<PrimarySignature> GetPrimarySignatureAsync(CancellationToken token)
+        {
+            return TaskResult.Null<PrimarySignature>();
+        }
+
+        public override Task<bool> IsSignedAsync(CancellationToken token)
+        {
+            return TaskResult.False;
+        }
+
+        public override Task ValidateIntegrityAsync(SignatureContent signatureContent, CancellationToken token)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override Task<byte[]> GetArchiveHashAsync(HashAlgorithmName hashAlgorithm, CancellationToken token)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override bool CanVerifySignedPackages(SignedPackageVerifierSettings verifierSettings)
+        {
+            return false;
+        }
+
+        public override string GetContentHash(CancellationToken token, Func<string> GetUnsignedPackageHash = null)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

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

@@ -214,6 +214,77 @@ public partial class EntryPointTests
             });
         }
 
+        [Fact]
+        public async Task WithDuplicateDependenciesOfDifferentTypes()
+        {
+            var projectPath = "path/to/my.csproj";
+            var directoryBuildPropsPath = "path/Directory.Build.props";
+            await RunAsync(path =>
+            [
+                "discover",
+                "--repo-root",
+                path,
+                "--workspace",
+                path,
+            ],
+            new[]
+            {
+                (projectPath, """
+                    <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Newtonsoft.Json" Version="7.0.1" />
+                      </ItemGroup>
+                      <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                    </Project>
+                    """),
+                (directoryBuildPropsPath, """
+                    <Project>
+                        <ItemGroup Condition="'$(ManagePackageVersionsCentrally)' == 'true'">
+                          <GlobalPackageReference Include="System.Text.Json" Version="8.0.3" />
+                        </ItemGroup>
+                        <ItemGroup Condition="'$(ManagePackageVersionsCentrally)' != 'true'">
+                          <PackageReference Include="System.Text.Json" Version="8.0.3" />
+                        </ItemGroup>
+                    </Project>
+                    """)
+            },
+            expectedResult: new()
+            {
+                FilePath = "",
+                Projects = [
+                    new()
+                    {
+                        FilePath = projectPath,
+                        TargetFrameworks = ["net8.0"],
+                        ReferencedProjectPaths = [],
+                        ExpectedDependencyCount = 2,
+                        Dependencies = [
+                            new("Newtonsoft.Json", "7.0.1", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
+                            // $(ManagePackageVersionsCentrally) evaluates false by default, we only get a PackageReference
+                            new("System.Text.Json", "8.0.3", DependencyType.PackageReference, TargetFrameworks: ["net8.0"])
+                        ],
+                        Properties = [
+                            new("TargetFramework", "net8.0", "path/to/my.csproj"),
+                        ],
+                    },
+                    new()
+                    {
+                        FilePath = directoryBuildPropsPath,
+                        ReferencedProjectPaths = [],
+                        ExpectedDependencyCount = 2,
+                        Dependencies = [
+                            new("System.Text.Json", "8.0.3", DependencyType.PackageReference, IsDirect: true),
+                            new("System.Text.Json", "8.0.3", DependencyType.GlobalPackageReference, IsDirect: true)
+                        ],
+                        Properties = [],
+                    }
+                ]
+            });
+        }
+
         private static async Task RunAsync(
             Func<string, string[]> getArgs,
             TestFile[] initialFiles,

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

@@ -29,24 +29,25 @@ internal static class SdkProjectDiscovery
 
                 // The build file dependencies have the correct DependencyType and the TopLevelDependencies have the evaluated version.
                 // Combine them to have the set of dependencies that are directly referenced from the build file.
-                var fileDependencies = BuildFile.GetDependencies(buildFile)
-                    .ToDictionary(d => d.Name, StringComparer.OrdinalIgnoreCase);
-                var sdkDependencies = fileDependencies.Values
+                var fileDependencies = BuildFile.GetDependencies(buildFile).ToImmutableArray();
+                var fileDependencyLookup = fileDependencies
+                    .ToLookup(d => d.Name, StringComparer.OrdinalIgnoreCase);
+                var sdkDependencies = fileDependencies
                     .Where(d => d.Type == DependencyType.MSBuildSdk)
                     .ToImmutableArray();
                 var indirectDependencies = topLevelDependencies
-                    .Where(d => !fileDependencies.ContainsKey(d.Name))
+                    .Where(d => !fileDependencyLookup.Contains(d.Name))
                     .ToImmutableArray();
                 var directDependencies = topLevelDependencies
-                    .Where(d => fileDependencies.ContainsKey(d.Name))
-                    .Select(d =>
+                    .Where(d => fileDependencyLookup.Contains(d.Name))
+                    .SelectMany(d =>
                     {
-                        var dependency = fileDependencies[d.Name];
-                        return d with
+                        var dependencies = fileDependencyLookup[d.Name];
+                        return dependencies.Select(fileDependency => d with
                         {
-                            Type = dependency.Type,
+                            Type = fileDependency.Type,
                             IsDirect = true
-                        };
+                        });
                     }).ToImmutableArray();
 
                 if (buildFile.GetFileType() == ProjectBuildFileType.Project)

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

@@ -1,9 +1,6 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using System.Text;
-using System.Threading.Tasks;
+using System.Xml.Linq;
+using System.Xml.XPath;
 
 using Microsoft.Language.Xml;
 
@@ -23,7 +20,7 @@ internal static class PackagesConfigUpdater
         string dependencyName,
         string previousDependencyVersion,
         string newDependencyVersion,
-        bool isTransitive,
+        string packagesConfigPath,
         Logger logger
     )
     {
@@ -33,7 +30,7 @@ internal static class PackagesConfigUpdater
 
         // ensure local packages directory exists
         var projectBuildFile = ProjectBuildFile.Open(repoRootPath, projectPath);
-        var packagesSubDirectory = GetPathToPackagesDirectory(projectBuildFile, dependencyName, previousDependencyVersion);
+        var packagesSubDirectory = GetPathToPackagesDirectory(projectBuildFile, dependencyName, previousDependencyVersion, packagesConfigPath);
         if (packagesSubDirectory is null)
         {
             logger.Log($"    Project [{projectPath}] does not reference this dependency.");
@@ -43,8 +40,6 @@ internal static class PackagesConfigUpdater
         logger.Log($"    Using packages directory [{packagesSubDirectory}] for project [{projectPath}].");
 
         var projectDirectory = Path.GetDirectoryName(projectPath);
-        var packagesConfigPath = PathHelper.JoinPath(projectDirectory, NuGetHelper.PackagesConfigFileName);
-
         var packagesDirectory = PathHelper.JoinPath(projectDirectory, packagesSubDirectory);
         Directory.CreateDirectory(packagesDirectory);
 
@@ -83,7 +78,7 @@ internal static class PackagesConfigUpdater
 
         using (new WebApplicationTargetsConditionPatcher(projectPath))
         {
-            RunNuget(updateArgs, restoreArgs, packagesDirectory, logger);
+            RunNugetUpdate(updateArgs, restoreArgs, projectDirectory ?? packagesDirectory, logger);
         }
 
         projectBuildFile = ProjectBuildFile.Open(repoRootPath, projectPath);
@@ -96,7 +91,7 @@ internal static class PackagesConfigUpdater
         await projectBuildFile.SaveAsync();
     }
 
-    private static void RunNuget(List<string> updateArgs, List<string> restoreArgs, string packagesDirectory, Logger logger)
+    private static void RunNugetUpdate(List<string> updateArgs, List<string> restoreArgs, string projectDirectory, Logger logger)
     {
         var outputBuilder = new StringBuilder();
         var writer = new StringWriter(outputBuilder);
@@ -110,7 +105,7 @@ internal static class PackagesConfigUpdater
         try
         {
 
-            Environment.CurrentDirectory = packagesDirectory;
+            Environment.CurrentDirectory = projectDirectory;
             var retryingAfterRestore = false;
 
         doRestore:
@@ -122,13 +117,21 @@ internal static class PackagesConfigUpdater
             logger.Log($"    Output:\n{fullOutput}");
             if (result != 0)
             {
-                // If the `packages.config` file contains a delisted package, the initial `update` operation will fail
-                // with the message listed below.  The solution is to run `nuget.exe restore ...` and retry.
+                // The initial `update` command can fail for several reasons:
+                // 1. One possibility is that the `packages.config` file contains a delisted package.  If that's the
+                //    case, `update` will fail with the message "Existing packages must be restored before performing
+                //    an install or update."
+                // 2. Another possibility is that the `update` command fails because the package contains no assemblies
+                //    and doesn't appear in the cache.  The message in this case will be "Could not install package
+                //    '<name> <version>'...the package does not contain any assembly references or content files that
+                //    are compatible with that framework.".
+                // The solution in all cases is to run `restore` then try the update again.
                 if (!retryingAfterRestore &&
-                    fullOutput.Contains("Existing packages must be restored before performing an install or update."))
+                    (fullOutput.Contains("Existing packages must be restored before performing an install or update.") ||
+                    fullOutput.Contains("the package does not contain any assembly references or content files that are compatible with that framework.")))
                 {
-                    logger.Log($"    Running NuGet.exe with args: {string.Join(" ", restoreArgs)}");
                     retryingAfterRestore = true;
+                    logger.Log($"    Running NuGet.exe with args: {string.Join(" ", restoreArgs)}");
                     outputBuilder.Clear();
                     var exitCodeAgain = Program.Main(restoreArgs.ToArray());
                     var restoreOutput = outputBuilder.ToString();
@@ -157,7 +160,7 @@ internal static class PackagesConfigUpdater
         }
     }
 
-    internal static string? GetPathToPackagesDirectory(ProjectBuildFile projectBuildFile, string dependencyName, string dependencyVersion)
+    internal static string? GetPathToPackagesDirectory(ProjectBuildFile projectBuildFile, string dependencyName, string dependencyVersion, string packagesConfigPath)
     {
         // the packages directory can be found from the hint path of the matching dependency, e.g., when given "Newtonsoft.Json", "7.0.1", and a project like this:
         // <Project>
@@ -203,6 +206,24 @@ internal static class PackagesConfigUpdater
             }
         }
 
+        if (partialPathMatch is null)
+        {
+            // if we got this far, we couldn't find the packages directory for the specified dependency and there are 2 possibilities:
+            // 1. the dependency doesn't actually exist in this project
+            // 2. the dependency exists, but doesn't have any assemblies, e.g., jQuery
+
+            // first let's check the packages.config file to see if we actually need it.
+            XDocument packagesDocument = XDocument.Load(packagesConfigPath);
+            var hasPackage = packagesDocument.XPathSelectElements("/packages/package")
+                .Where(e => e.Attribute("id")?.Value.Equals(dependencyName, StringComparison.OrdinalIgnoreCase) == true).Any();
+            if (hasPackage)
+            {
+                // the dependency exists in the packages.config file, so it must be the second case
+                // the vast majority of projects found in the wild use this, and since we have nothing to look for, we'll just have to hope
+                partialPathMatch = "../packages";
+            }
+        }
+
         return partialPathMatch;
     }
 

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

@@ -134,9 +134,9 @@ public class UpdaterWorker
 
         _logger.Log($"Updating project [{projectPath}]");
 
-        if (NuGetHelper.TryGetPackagesConfigFile(projectPath, out _))
+        if (NuGetHelper.TryGetPackagesConfigFile(projectPath, out var packagesConfigPath))
         {
-            await PackagesConfigUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, _logger);
+            await PackagesConfigUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, packagesConfigPath, _logger);
         }
 
         // Some repos use a mix of packages.config and PackageReference

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

@@ -91,7 +91,7 @@ public class DiscoveryWorkerTestBase
 
             foreach (var expectedDependency in expectedDependencies)
             {
-                var actualDependency = actualDependencies.Single(d => d.Name == expectedDependency.Name);
+                var actualDependency = actualDependencies.Single(d => d.Name == expectedDependency.Name && d.Type == expectedDependency.Type);
                 Assert.Equal(expectedDependency.Name, actualDependency.Name);
                 Assert.Equal(expectedDependency.Version, actualDependency.Version);
                 Assert.Equal(expectedDependency.Type, actualDependency.Type);

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/PackagesConfigUpdaterTests.cs

@@ -9,7 +9,7 @@ public class PackagesConfigUpdaterTests : TestBase
     public void PathToPackagesDirectoryCanBeDetermined(string projectContents, string dependencyName, string dependencyVersion, string expectedPackagesDirectoryPath)
     {
         var projectBuildFile = ProjectBuildFile.Parse("/", "project.csproj", projectContents);
-        var actualPackagesDirectorypath = PackagesConfigUpdater.GetPathToPackagesDirectory(projectBuildFile, dependencyName, dependencyVersion);
+        var actualPackagesDirectorypath = PackagesConfigUpdater.GetPathToPackagesDirectory(projectBuildFile, dependencyName, dependencyVersion, "packages.config");
         Assert.Equal(expectedPackagesDirectoryPath, actualPackagesDirectorypath);
     }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.PackagesConfig.cs

@@ -1,6 +1,3 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
 using Xunit;
 
 namespace NuGetUpdater.Core.Test.Update;
@@ -121,6 +118,109 @@ public partial class UpdateWorkerTests
                 """);
         }
 
+        [Fact]
+        public async Task UpdateSingleDependencyInPackagesConfig_SpecifiedDependencyHasNoPackagesPath()
+        {
+            // update jQuery from 1.6.4 to 3.7.1
+            await TestUpdateForProject("jQuery", "1.6.4", "3.7.1",
+                // existing
+                projectContents: """
+                    <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+                      <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+                      <PropertyGroup>
+                        <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <None Include="packages.config" />
+                      </ItemGroup>
+                      <ItemGroup>
+                        <Reference Include="Newtonsoft.Json">
+                          <HintPath>packages\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+                          <Private>True</Private>
+                        </Reference>
+                      </ItemGroup>
+                      <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                    </Project>
+                    """,
+                packagesConfigContents: """
+                    <packages>
+                      <package id="jQuery" version="1.6.4" targetFramework="net45" />
+                      <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net45" />
+                    </packages>
+                    """,
+                // expected
+                expectedProjectContents: """
+                    <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+                      <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+                      <PropertyGroup>
+                        <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <None Include="packages.config" />
+                      </ItemGroup>
+                      <ItemGroup>
+                        <Reference Include="Newtonsoft.Json">
+                          <HintPath>packages\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+                          <Private>True</Private>
+                        </Reference>
+                      </ItemGroup>
+                      <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                    </Project>
+                    """,
+                expectedPackagesConfigContents: """
+                    <?xml version="1.0" encoding="utf-8"?>
+                    <packages>
+                      <package id="jQuery" version="3.7.1" targetFramework="net46" />
+                      <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net45" />
+                    </packages>
+                    """
+            );
+        }
+
+        [Fact]
+        public async Task UpdateSingleDependencyInPackagesConfig_NoPackagesPathCanBeFound()
+        {
+            // update jQuery from 3.7.0 to 3.7.1
+            await TestUpdateForProject("jQuery", "3.7.0", "3.7.1",
+                // existing
+                projectContents: """
+                    <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+                      <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+                      <PropertyGroup>
+                        <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <None Include="packages.config" />
+                      </ItemGroup>
+                      <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                    </Project>
+                    """,
+                packagesConfigContents: """
+                    <packages>
+                      <package id="jQuery" version="3.7.0" targetFramework="net45" />
+                    </packages>
+                    """,
+                // expected
+                expectedProjectContents: """
+                    <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+                      <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+                      <PropertyGroup>
+                        <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <None Include="packages.config" />
+                      </ItemGroup>
+                      <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                    </Project>
+                    """,
+                expectedPackagesConfigContents: """
+                    <?xml version="1.0" encoding="utf-8"?>
+                    <packages>
+                      <package id="jQuery" version="3.7.1" targetFramework="net45" />
+                    </packages>
+                    """);
+        }
+
         [Fact]
         public async Task UpdateSingleDependencyInPackagesConfigButNotToLatest()
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/SdkPackageUpdaterHelperTests.cs

@@ -2,7 +2,7 @@ using Xunit;
 
 namespace NuGetUpdater.Core.Test.Utilities
 {
-    public class SdkPackageUpdaterHelperTests
+    public class SdkPackageUpdaterHelperTests : TestBase
     {
         [Fact]
         public async Task DirectoryBuildFilesAreOnlyPulledInFromParentDirectories()

data/lib/dependabot/nuget/file_parser.rb

@@ -21,6 +21,7 @@ module Dependabot
       def parse
         workspace_path = project_files.first&.directory
         return [] unless workspace_path
+        return [] unless repo_contents_path
 
         # `workspace_path` is the only unique value here so we use it as the cache key
         cache = T.let(CacheManager.cache("file_parser.parse"), T::Hash[String, T::Array[Dependabot::Dependency]])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dependabot-nuget
 version: !ruby/object:Gem::Version
-  version: 0.254.0
+  version: 0.255.0
 platform: ruby
 authors:
 - Dependabot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-24 00:00:00.000000000 Z
+date: 2024-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dependabot-common
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.254.0
+        version: 0.255.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.254.0
+        version: 0.255.0
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
@@ -184,6 +184,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
 - !ruby/object:Gem::Dependency
   name: turbo_tests
   requirement: !ruby/object:Gem::Requirement
@@ -270,6 +284,7 @@ files:
 - helpers/lib/NuGetUpdater/NuGetProjects/NuGet.LibraryModel/NuGet.LibraryModel.csproj
 - helpers/lib/NuGetUpdater/NuGetProjects/NuGet.PackageManagement/NuGet.PackageManagement.csproj
 - helpers/lib/NuGetUpdater/NuGetProjects/NuGet.Packaging/NuGet.Packaging.csproj
+- helpers/lib/NuGetUpdater/NuGetProjects/NuGet.Packaging/PackageFolderReader.cs
 - helpers/lib/NuGetUpdater/NuGetProjects/NuGet.ProjectModel/NuGet.ProjectModel.csproj
 - helpers/lib/NuGetUpdater/NuGetProjects/NuGet.Protocol/NuGet.Protocol.csproj
 - helpers/lib/NuGetUpdater/NuGetProjects/NuGet.Resolver/NuGet.Resolver.csproj
@@ -404,7 +419,7 @@ licenses:
 - Nonstandard
 metadata:
   bug_tracker_uri: https://github.com/dependabot/dependabot-core/issues
-  changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.254.0
+  changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.255.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -420,7 +435,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.1.0
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.9
 signing_key: 
 specification_version: 4
 summary: Provides Dependabot support for .NET (NuGet)