dependabot-nuget 0.394.0 → 0.396.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f87265e6a1903fa2d9a3ebf527ce5a2011050a3166b4dc38e0e5ed973047ed3
-  data.tar.gz: a34d83e590e6a578617e53ac28407412492c01c62c198f910929246c3af3b405
+  metadata.gz: 3c8d2c369fea3791d04cedce39111d000bc6d0052f48a6df16116b9c811b1f4c
+  data.tar.gz: '08c4cec0fef16173ca1d28eb497127064b4ecc5daeb2a2d84f3ab8ee72cc6852'
 SHA512:
-  metadata.gz: d3d30fb0420935c01ec7fa4d8d08538994cd51bc4c4e4875b717f85ede40bcbec970b0e127bc9d830c6bdc9de8ef3048340d49bc36efcd307c4d2c57a5e82e4c
-  data.tar.gz: 54406d1b180a7da9baf7fd61f9aba249d8eae142eda7404f96c6f9c364184f600d49b3ea61daa756f86f7ad005026560623522003712801a149a176c8863ec4b
+  metadata.gz: 220207aba4f007a902a08030847f865afad86e57de5dfcbfe81d9a6ef5bdaa5284ace3c4259f122778a69ad6401e42645858dd09516edf75055b14c48f3c4f59
+  data.tar.gz: c309c50fd55d24516bca819ff47c5b3981b867fe7d15a5990505c2ad0e527e999d0aa988fcb81c359e98291eb8da983edae2a7d803e7677530bf0dfef8fc85da

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

@@ -27,20 +27,20 @@
     <PackageVersion Include="MSBuild.StructuredLogger" Version="2.3.246" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.4" />
     <PackageVersion Include="OpenTelemetry" Version="1.18.0" />
-    <PackageVersion Include="OpenTelemetry.Exporter.Console" Version="1.15.3" />
+    <PackageVersion Include="OpenTelemetry.Exporter.Console" Version="1.18.0" />
     <PackageVersion Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.18.0" />
     <PackageVersion Include="packageurl-dotnet" Version="2.0.1" />
     <PackageVersion Include="Semver" Version="3.0.0" />
-    <PackageVersion Include="System.CommandLine" Version="2.0.3" />
-    <PackageVersion Include="System.ComponentModel.Composition" Version="10.0.3" />
+    <PackageVersion Include="System.CommandLine" Version="2.0.11" />
+    <PackageVersion Include="System.ComponentModel.Composition" Version="10.0.11" />
     <PackageVersion Include="System.Net.Http" Version="4.3.4" />
     <PackageVersion Include="System.Formats.Asn1" Version="10.0.3" />
-    <PackageVersion Include="System.Security.Cryptography.Pkcs" Version="10.0.10" />
-    <PackageVersion Include="System.Security.Cryptography.ProtectedData" Version="10.0.8" />
-    <PackageVersion Include="System.Text.Json" Version="10.0.3" />
+    <PackageVersion Include="System.Security.Cryptography.Pkcs" Version="10.0.11" />
+    <PackageVersion Include="System.Security.Cryptography.ProtectedData" Version="10.0.11" />
+    <PackageVersion Include="System.Text.Json" Version="10.0.11" />
     <PackageVersion Include="System.Text.RegularExpressions" Version="4.3.1" />
-    <PackageVersion Include="System.Threading.Tasks.Dataflow" Version="10.0.3" />
+    <PackageVersion Include="System.Threading.Tasks.Dataflow" Version="10.0.11" />
     <PackageVersion Include="xunit.v3" Version="3.2.2" />
-    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="4.0.0" />
   </ItemGroup>
 </Project>

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

@@ -16,6 +16,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="System.Security.Cryptography.Pkcs" />
     <EmbeddedResource Include="$(NuGetSourceLocation)\src\NuGet.Core\NuGet.Protocol\**\*.resx" />
   </ItemGroup>
 

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

@@ -65,6 +65,8 @@ internal static class SdkProjectDiscovery
     // these targets are required to evaluate a legacy project with a single operation
     private static readonly ImmutableArray<string> LegacyProjectSingleRestoreTargetNames = ["ResolveProjectReferences"];
 
+    private const string TargetFrameworksPropertyName = "TargetFrameworks";
+
     // this property evaluates to a version number in an SDK-style project and is unset or empty otherwise
     private const string NETCoreSdkVersionPropertyName = "NETCoreSdkVersion";
 
@@ -119,16 +121,30 @@ internal static class SdkProjectDiscovery
         Dictionary<string, HashSet<string>> additionalFiles = new(PathComparer.Instance);
         //    projectPath  additionalFiles
 
+        var startingProjectProperties = await MSBuildHelper.GetProjectPropertiesAsync(
+            startingProjectPath,
+            [TargetFrameworksPropertyName, NETCoreSdkVersionPropertyName],
+            logger
+        );
+        var projectTfms = MSBuildHelper.ParseProjectTargetFrameworks(startingProjectProperties?.GetValueOrDefault(TargetFrameworksPropertyName));
+        var netCoreSdkVersionValue = startingProjectProperties?.GetValueOrDefault(NETCoreSdkVersionPropertyName);
+        var isLegacyProject = string.IsNullOrEmpty(netCoreSdkVersionValue);
+        var requiredTargets = isLegacyProject
+            ? LegacyProjectSingleRestoreTargetNames
+            : SingleRestoreTargetNames;
+
         // due to how MSBuild handles multi-TFM projects with target platforms we may need to process each TFM separately
         // we detect that by determining if there are multiple target frameworks specified and if any of them have a platform suffix (e.g., `-windows`, `-android`, etc)
         // alternately, if there are too many target frameworks specified, they must be handled individually
-        var projectTfms = await MSBuildHelper.GetProjectTargetFrameworksAsync(startingProjectPath, logger);
         var hasPlatformTfms = projectTfms.Any(tfm => tfm.Contains('-'));
         var requiresIndividualRestores = hasPlatformTfms || projectTfms.Length > MaximumParallelTargetFrameworkRestores;
+        var useDirectRestore = requiresIndividualRestores;
         if (!requiresIndividualRestores)
         {
             logger.Info($"Performing single restore for project {startingProjectPath}");
             projectTfms = [string.Empty]; // a single restore can handle everything, but we need to loop at least once and an empty TFM is our signal to not specify anything
+            var actualTargets = await MSBuildHelper.GetProjectTargetsAsync(startingProjectPath, logger);
+            useDirectRestore = requiredTargets.All(actualTargets.Contains);
         }
         else
         {
@@ -158,15 +174,7 @@ internal static class SdkProjectDiscovery
                 // `ResolveProjectReferences` to gather all `PackageReference` items and further down we re-build the transitive
                 // dependency set.  Without the legacy project check, we could incorrectly invoke `Build` which eventually tries
                 // to call `csc.exe` which is unnecessary and can be slow.
-                var netCoreSdkVersionValue = await MSBuildHelper.GetProjectPropertyAsync(startingProjectPath, NETCoreSdkVersionPropertyName, logger);
-                var isLegacyProject = string.IsNullOrEmpty(netCoreSdkVersionValue);
-                var requiredTargets = isLegacyProject
-                    ? LegacyProjectSingleRestoreTargetNames
-                    : SingleRestoreTargetNames;
-
-                var actualTargets = await MSBuildHelper.GetProjectTargetsAsync(startingProjectPath, logger);
-                var useDirectRestore = requiredTargets.All(actualTargets.Contains);
-                if (useDirectRestore || isIndividualTfmRestore)
+                if (useDirectRestore)
                 {
                     // directly call the required targets
                     args.Add($"/t:{string.Join(",", requiredTargets)}");

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

@@ -4,7 +4,7 @@ using System.Text.Json.Serialization;
 
 namespace NuGetUpdater.Core.Run;
 
-public class HttpApiHandler : IApiHandler
+public class HttpApiHandler : IApiHandler, IApiRetryDelayProvider
 {
     private static readonly HttpClient HttpClient = new();
 
@@ -16,13 +16,22 @@ public class HttpApiHandler : IApiHandler
 
     private readonly string _apiUrl;
     private readonly string _jobId;
+    private readonly Func<TimeSpan, Task> _retryDelay;
 
     public HttpApiHandler(string apiUrl, string jobId)
+        : this(apiUrl, jobId, Task.Delay)
+    {
+    }
+
+    internal HttpApiHandler(string apiUrl, string jobId, Func<TimeSpan, Task> retryDelay)
     {
         _apiUrl = apiUrl.TrimEnd('/');
         _jobId = jobId;
+        _retryDelay = retryDelay;
     }
 
+    Task IApiRetryDelayProvider.DelayAsync(TimeSpan delay) => _retryDelay(delay);
+
     public async Task SendAsync(string endpoint, object body, string method)
     {
         var uri = $"{_apiUrl}/update_jobs/{_jobId}/{endpoint}";

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

@@ -7,6 +7,11 @@ public interface IApiHandler
     Task SendAsync(string endpoint, object body, string method);
 }
 
+internal interface IApiRetryDelayProvider
+{
+    Task DelayAsync(TimeSpan delay);
+}
+
 public static class IApiHandlerExtensions
 {
     public static async Task RecordUpdateJobError(this IApiHandler handler, JobErrorBase error, ILogger logger)
@@ -70,7 +75,15 @@ public static class IApiHandlerExtensions
                 (ex.StatusCode is null || ((int)ex.StatusCode) / 100 == 5))
             {
                 retryCount++;
-                await Task.Delay(TimeSpan.FromSeconds(Random.Shared.Next(MinRetryDelay, MaxRetryDelay)));
+                var delay = TimeSpan.FromSeconds(Random.Shared.Next(MinRetryDelay, MaxRetryDelay));
+                if (handler is IApiRetryDelayProvider delayProvider)
+                {
+                    await delayProvider.DelayAsync(delay);
+                }
+                else
+                {
+                    await Task.Delay(delay);
+                }
             }
         }
     }

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

@@ -1,6 +1,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
+using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.RegularExpressions;
 using System.Xml.Linq;
@@ -563,7 +564,11 @@ internal static partial class MSBuildHelper
         return targets;
     }
 
-    internal static async Task<string?> GetProjectPropertyAsync(string projectPath, string propertyName, ILogger logger)
+    internal static async Task<ImmutableDictionary<string, string>?> GetProjectPropertiesAsync(
+        string projectPath,
+        IReadOnlyCollection<string> propertyNames,
+        ILogger logger
+    )
     {
         var extension = Path.GetExtension(projectPath)?.ToLowerInvariant();
         if (extension == ".sln" || extension == ".slnx")
@@ -572,51 +577,128 @@ internal static partial class MSBuildHelper
             return null;
         }
 
-        var projectDirectory = Path.GetDirectoryName(projectPath)!;
-        var args = new[]
+        var requestedPropertyNames = propertyNames
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToImmutableArray();
+        if (requestedPropertyNames.Length == 0)
         {
-            projectPath,
-            $"-getProperty:{propertyName}"
-        };
+            return ImmutableDictionary.Create<string, string>(StringComparer.OrdinalIgnoreCase);
+        }
 
-        var (exitCode, stdOut, stdErr) = await ProcessEx.RunDotnetMSBuildSafelyAsync(args, projectDirectory);
-        if (exitCode != 0)
+        if (requestedPropertyNames.Length == 1)
+        {
+            var propertyName = requestedPropertyNames[0];
+            var propertyValue = await GetProjectPropertyAsync(projectPath, propertyName, logger);
+            return propertyValue is null
+                ? null
+                : ImmutableDictionary.Create<string, string>(StringComparer.OrdinalIgnoreCase).Add(propertyName, propertyValue);
+        }
+
+        var projectDirectory = Path.GetDirectoryName(projectPath)!;
+        var tempDir = Directory.CreateTempSubdirectory("__get_msbuild_properties_");
+        try
         {
-            if (stdOut.Contains("error MSB1001: Unknown switch."))
+            var resultOutputPath = Path.Combine(tempDir.FullName, "result.json");
+            var args = new[]
             {
-                // older versions of MSBuild don't allow `-getProperty` so we go a different route
-                // we can't force an indirect property evaluation, but we can force import a custom targets file that effectively renames the property
-                var tempDir = Directory.CreateTempSubdirectory("__get_msbuild_property_");
-                try
+                projectPath,
+                $"-getProperty:{string.Join(",", requestedPropertyNames)}",
+                $"-getResultOutputFile:{resultOutputPath}",
+            };
+
+            var (exitCode, stdOut, stdErr) = await ProcessEx.RunDotnetMSBuildSafelyAsync(args, projectDirectory);
+            if (exitCode != 0)
+            {
+                if (IsGetPropertyUnsupported(stdOut, stdErr))
                 {
-                    // prepare magic contents
-                    var targetsTemplateContents = await File.ReadAllTextAsync(GetFileFromRuntimeDirectory("GetProperty.targets"));
-                    var targetContents = targetsTemplateContents.Replace("%RequestedPropertyName%", $"$({propertyName})");
-
-                    // write magic contents
-                    var tempTargetsPath = Path.Combine(tempDir.FullName, $"GetProperty_{propertyName}.targets");
-                    await File.WriteAllTextAsync(tempTargetsPath, targetContents);
-
-                    // do it
-                    args = [
-                        projectPath,
-                        $"/p:CustomAfterMicrosoftCommonTargets={tempTargetsPath}",
-                        "/t:_Dependabot_GetProperty",
-                    ];
-                    (exitCode, stdOut, stdErr) = await ProcessEx.RunDotnetMSBuildSafelyAsync(args, projectDirectory);
-                    if (exitCode == 0)
+                    var fallbackProperties = ImmutableDictionary.CreateBuilder<string, string>(StringComparer.OrdinalIgnoreCase);
+                    foreach (var propertyName in requestedPropertyNames)
                     {
-                        var match = Regex.Match(stdOut, "__PROPERTY_VALUE:(?<PropertyValue>[^$]*)$", RegexOptions.Multiline);
-                        if (match.Success)
+                        var propertyValue = await GetProjectPropertyUsingCompatibilityTargetAsync(projectPath, propertyName, logger);
+                        if (propertyValue is null)
                         {
-                            return match.Groups["PropertyValue"].Value.Trim();
+                            return null;
                         }
+
+                        fallbackProperties[propertyName] = propertyValue;
                     }
+
+                    return fallbackProperties.ToImmutable();
                 }
-                finally
+
+                logger.Warn($"Unable to determine properties '{string.Join("', '", requestedPropertyNames)}' for project [{projectPath}]:\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}\n");
+                return null;
+            }
+
+            if (!File.Exists(resultOutputPath))
+            {
+                logger.Warn($"Unable to determine properties '{string.Join("', '", requestedPropertyNames)}' for project [{projectPath}]: MSBuild did not produce a result output file.\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}\n");
+                return null;
+            }
+
+            var resultOutput = await File.ReadAllTextAsync(resultOutputPath);
+            try
+            {
+                using var resultDocument = JsonDocument.Parse(resultOutput);
+                var root = resultDocument.RootElement;
+                if (root.ValueKind != JsonValueKind.Object ||
+                    !root.TryGetProperty("Properties", out var propertiesElement) ||
+                    propertiesElement.ValueKind != JsonValueKind.Object)
                 {
-                    tempDir.Delete(recursive: true);
+                    logger.Warn($"Unable to determine properties '{string.Join("', '", requestedPropertyNames)}' for project [{projectPath}]: MSBuild result output did not contain a properties object.");
+                    return null;
                 }
+
+                var properties = ImmutableDictionary.CreateBuilder<string, string>(StringComparer.OrdinalIgnoreCase);
+                foreach (var propertyName in requestedPropertyNames)
+                {
+                    if (!propertiesElement.TryGetProperty(propertyName, out var propertyElement) ||
+                        propertyElement.ValueKind != JsonValueKind.String ||
+                        propertyElement.GetString() is not string propertyValue)
+                    {
+                        logger.Warn($"Unable to determine property '{propertyName}' for project [{projectPath}]: MSBuild result output did not contain a string value for the property.");
+                        return null;
+                    }
+
+                    properties[propertyName] = propertyValue;
+                }
+
+                return properties.ToImmutable();
+            }
+            catch (JsonException ex)
+            {
+                logger.Warn($"Unable to determine properties '{string.Join("', '", requestedPropertyNames)}' for project [{projectPath}]: MSBuild produced invalid JSON result output: {ex.Message}");
+                return null;
+            }
+        }
+        finally
+        {
+            tempDir.Delete(recursive: true);
+        }
+    }
+
+    internal static async Task<string?> GetProjectPropertyAsync(string projectPath, string propertyName, ILogger logger)
+    {
+        var extension = Path.GetExtension(projectPath)?.ToLowerInvariant();
+        if (extension == ".sln" || extension == ".slnx")
+        {
+            // solution files don't specify properties, so we can skip the process invocation
+            return null;
+        }
+
+        var projectDirectory = Path.GetDirectoryName(projectPath)!;
+        var args = new[]
+        {
+            projectPath,
+            $"-getProperty:{propertyName}"
+        };
+
+        var (exitCode, stdOut, stdErr) = await ProcessEx.RunDotnetMSBuildSafelyAsync(args, projectDirectory);
+        if (exitCode != 0)
+        {
+            if (IsGetPropertyUnsupported(stdOut, stdErr))
+            {
+                return await GetProjectPropertyUsingCompatibilityTargetAsync(projectPath, propertyName, logger);
             }
 
             logger.Warn($"Unable to determine property '{propertyName}' for project [{projectPath}]:\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}\n");
@@ -629,6 +711,11 @@ internal static partial class MSBuildHelper
     internal static async Task<ImmutableArray<string>> GetProjectTargetFrameworksAsync(string projectPath, ILogger logger)
     {
         var rawValue = await GetProjectPropertyAsync(projectPath, "TargetFrameworks", logger);
+        return ParseProjectTargetFrameworks(rawValue);
+    }
+
+    internal static ImmutableArray<string> ParseProjectTargetFrameworks(string? rawValue)
+    {
         if (rawValue is null)
         {
             return [];
@@ -641,6 +728,49 @@ internal static partial class MSBuildHelper
         return tfms;
     }
 
+    private static bool IsGetPropertyUnsupported(string stdOut, string stdErr)
+    {
+        return stdOut.Contains("error MSB1001: Unknown switch.", StringComparison.Ordinal) ||
+            stdErr.Contains("error MSB1001: Unknown switch.", StringComparison.Ordinal);
+    }
+
+    private static async Task<string?> GetProjectPropertyUsingCompatibilityTargetAsync(string projectPath, string propertyName, ILogger logger)
+    {
+        // Older versions of MSBuild don't allow `-getProperty`, so import a custom target that reports the property.
+        var projectDirectory = Path.GetDirectoryName(projectPath)!;
+        var tempDir = Directory.CreateTempSubdirectory("__get_msbuild_property_");
+        try
+        {
+            var targetsTemplateContents = await File.ReadAllTextAsync(GetFileFromRuntimeDirectory("GetProperty.targets"));
+            var targetContents = targetsTemplateContents.Replace("%RequestedPropertyName%", $"$({propertyName})");
+            var tempTargetsPath = Path.Combine(tempDir.FullName, $"GetProperty_{propertyName}.targets");
+            await File.WriteAllTextAsync(tempTargetsPath, targetContents);
+
+            var args = new[]
+            {
+                projectPath,
+                $"/p:CustomAfterMicrosoftCommonTargets={tempTargetsPath}",
+                "/t:_Dependabot_GetProperty",
+            };
+            var (exitCode, stdOut, stdErr) = await ProcessEx.RunDotnetMSBuildSafelyAsync(args, projectDirectory);
+            if (exitCode == 0)
+            {
+                var match = Regex.Match(stdOut, "__PROPERTY_VALUE:(?<PropertyValue>[^$]*)$", RegexOptions.Multiline);
+                if (match.Success)
+                {
+                    return match.Groups["PropertyValue"].Value.Trim();
+                }
+            }
+
+            logger.Warn($"Unable to determine property '{propertyName}' for project [{projectPath}]:\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}\n");
+            return null;
+        }
+        finally
+        {
+            tempDir.Delete(recursive: true);
+        }
+    }
+
     internal static string? GetMissingFile(string output)
     {
         var missingFilePatterns = new[]

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

@@ -332,6 +332,7 @@ public class SdkProjectDiscoveryTests : DiscoveryWorkerTestBase
     [Theory]
     [InlineData("net7.0")] // under the safe limit for parallel processing
     [InlineData("net7.0", "net8.0")] // at the safe limit for parallel processing
+    [InlineData("net8.0", "net9.0-windows")] // platform-specific TFMs are processed individually
     [InlineData("net7.0", "net8.0", "net9.0")] // above the safe limit for parallel processing
     [InlineData("netstandard2.0", "netstandard2.1", "net6.0", "net7.0", "net8.0", "net9.0", "net10.0")] // well above the safe limit for parallel processing
     public async Task DiscoverWithMultipleTargetFrameworks(params string[] targetFrameworks)
@@ -798,4 +799,3 @@ public class SdkProjectDiscoveryTests : DiscoveryWorkerTestBase
         ValidateProjectResults(expectedProjects, projectDiscovery);
     }
 }
-

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

@@ -62,21 +62,24 @@ public class HttpApiHandlerTests
         var requestCount = 0;
         using var http = TestHttpServer.CreateTestServer((method, url) =>
         {
-            if (requestCount < 2)
+            requestCount++;
+            if (requestCount <= 2)
             {
-                requestCount++;
                 return (500, Array.Empty<byte>());
             }
 
             return (200, Array.Empty<byte>());
         });
-        var handler = new HttpApiHandler(http.BaseUrl, "TEST-ID");
+        var handler = new HttpApiHandler(http.BaseUrl, "TEST-ID", static _ => Task.CompletedTask);
 
         // act
         await handler.IncrementMetric(new()
         {
             Metric = "test",
         });
+
+        // assert
+        Assert.Equal(3, requestCount);
     }
 
     [Fact]
@@ -93,7 +96,29 @@ public class HttpApiHandlerTests
 
         // act
         await Assert.ThrowsAsync<HttpRequestException>(() => handler.IncrementMetric(new() { Metric = "test" }));
-        Assert.True(requestCount == 1, $"Expected only 1 request, but received {requestCount}.");
+
+        // assert
+        Assert.Equal(1, requestCount);
+    }
+
+    [Fact]
+    public async Task ApiCallsStopRetryingAfterTheMaximumNumberOfAttempts()
+    {
+        // arrange
+        var requestCount = 0;
+        using var http = TestHttpServer.CreateTestStringServer((method, url) =>
+        {
+            requestCount++;
+            return (500, $"attempt-{requestCount}");
+        });
+        var handler = new HttpApiHandler(http.BaseUrl, "TEST-ID", static _ => Task.CompletedTask);
+
+        // act
+        var exception = await Assert.ThrowsAsync<HttpRequestException>(() => handler.IncrementMetric(new() { Metric = "test" }));
+
+        // assert
+        Assert.Equal("500 (InternalServerError): attempt-4", exception.Message);
+        Assert.Equal(4, requestCount);
     }
 
     [Theory]

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

@@ -284,6 +284,79 @@ public class MSBuildHelperTests : TestBase
         AssertEx.Equal(expectedDependencies, actualDependencies);
     }
 
+    [Fact]
+    public async Task MultipleProjectPropertiesCanBeEvaluated()
+    {
+        using var tempDir = await TemporaryDirectory.CreateWithContentsAsync(
+        [
+            ("project.csproj", """
+                <Project Sdk="Microsoft.NET.Sdk">
+                  <PropertyGroup>
+                    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+                  </PropertyGroup>
+                </Project>
+                """)
+        ]);
+        var projectPath = Path.Combine(tempDir.DirectoryPath, "project.csproj");
+        var properties = await MSBuildHelper.GetProjectPropertiesAsync(
+            projectPath,
+            ["TargetFrameworks", "NETCoreSdkVersion"],
+            new TestLogger()
+        );
+
+        Assert.NotNull(properties);
+        Assert.Equal("net8.0;net9.0", properties["TargetFrameworks"]);
+        Assert.False(string.IsNullOrEmpty(properties["NETCoreSdkVersion"]));
+    }
+
+    [Theory]
+    [InlineData("TargetFrameworks")]
+    [InlineData("TargetFrameworks", "targetframeworks")]
+    public async Task SingleDistinctProjectPropertyCanBeEvaluated(params string[] propertyNames)
+    {
+        using var tempDir = await TemporaryDirectory.CreateWithContentsAsync(
+        [
+            ("project.csproj", """
+                <Project Sdk="Microsoft.NET.Sdk">
+                  <PropertyGroup>
+                    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+                  </PropertyGroup>
+                </Project>
+                """)
+        ]);
+        var projectPath = Path.Combine(tempDir.DirectoryPath, "project.csproj");
+        var properties = await MSBuildHelper.GetProjectPropertiesAsync(
+            projectPath,
+            propertyNames,
+            new TestLogger()
+        );
+
+        Assert.NotNull(properties);
+        Assert.Single(properties);
+        Assert.Equal("net8.0;net9.0", properties["TARGETFRAMEWORKS"]);
+    }
+
+    [Theory]
+    [InlineData(".sln")]
+    [InlineData(".slnx")]
+    public async Task MultipleProjectPropertiesAreNotEvaluatedForSolutions(string extension)
+    {
+        using var tempDir = await TemporaryDirectory.CreateWithContentsAsync(
+        [
+            ($"solution{extension}", string.Empty)
+        ]);
+        var solutionPath = Path.Combine(tempDir.DirectoryPath, $"solution{extension}");
+        var logger = new StringLogger();
+        var properties = await MSBuildHelper.GetProjectPropertiesAsync(
+            solutionPath,
+            ["TargetFrameworks", "NETCoreSdkVersion"],
+            logger
+        );
+
+        Assert.Null(properties);
+        Assert.Empty(logger.Messages);
+    }
+
     [Theory]
     [MemberData(nameof(GetTargetFrameworkValuesFromProjectData))]
     public async Task GetTargetFrameworkValuesFromProject(string projectContents, string[] expectedTfms)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dependabot-nuget
 version: !ruby/object:Gem::Version
-  version: 0.394.0
+  version: 0.396.0
 platform: ruby
 authors:
 - Dependabot
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.394.0
+        version: 0.396.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.394.0
+        version: 0.396.0
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -178,19 +178,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: turbo_tests
+  name: turbo_tests2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.5
+        version: 3.2.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.5
+        version: 3.2.7
 - !ruby/object:Gem::Dependency
   name: vcr
   requirement: !ruby/object:Gem::Requirement
@@ -587,7 +587,7 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/dependabot/dependabot-core/issues
-  changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.394.0
+  changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.396.0
 rdoc_options: []
 require_paths:
 - lib