fix: apply prerelease-aware range check when resolving installed workers (#5287)

* fix: apply prerelease-aware range check when resolving installed workers

Resolves #5286

The built-in profile (e.g. flex) pins workers to exact stable ranges
like node [3.13.0], but the v5 preview catalog only ships
3.13.0-preview.1. Per NuGet, 3.13.0-preview.1 < 3.13.0, so
VersionRange.Satisfies rejects the installed prerelease worker and
'func start' fails at the resolve_worker step.

PR #5257 fixed the same NuGet quirk on the catalog search path
(WorkloadCatalog.SatisfiesRange) but missed the installed-worker
resolver. Extract the prerelease-aware check into a shared helper
(WorkloadVersionRanges.SatisfiesRange) and use it from
DefaultFunctionsWorkerContentResolver as well, driven by the same
WorkloadCatalogOptions.IncludePrerelease that auto-enables on
prerelease CLI builds.

* release: bump to 5.0.0-preview.2 and note worker resolver fix

Author: liliankasem

src/Directory.Version.props

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <VersionPrefix>5.0.0</VersionPrefix>
-    <VersionSuffix>preview.1</VersionSuffix>
+    <VersionSuffix>preview.2</VersionSuffix>
     <UpdateBuildNumber>true</UpdateBuildNumber>
   </PropertyGroup>
 

src/Func/Workers/DefaultFunctionsWorkerContentResolver.cs

@@ -2,20 +2,27 @@
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
 using Azure.Functions.Cli.Workloads;
+using Azure.Functions.Cli.Workloads.Catalog;
+using Microsoft.Extensions.Options;
 using NuGet.Versioning;
 
 namespace Azure.Functions.Cli.Workers;
 
 /// <summary>
 /// Default worker resolver for content workload payloads.
 /// </summary>
-internal sealed class DefaultFunctionsWorkerContentResolver(IWorkerConfigFileSystem workerConfigFileSystem) : IFunctionsWorkerContentResolver
+internal sealed class DefaultFunctionsWorkerContentResolver(
+    IWorkerConfigFileSystem workerConfigFileSystem,
+    IOptions<WorkloadCatalogOptions> catalogOptions) : IFunctionsWorkerContentResolver
 {
     private const string WorkerConfigFileName = "worker.config.json";
 
     private readonly IWorkerConfigFileSystem _workerConfigFileSystem = workerConfigFileSystem
         ?? throw new ArgumentNullException(nameof(workerConfigFileSystem));
 
+    private readonly WorkloadCatalogOptions _catalogOptions = catalogOptions?.Value
+        ?? throw new ArgumentNullException(nameof(catalogOptions));
+
     public FunctionsWorkerResolutionResult ResolveWorker(
         FunctionsWorkerId workerId,
         IReadOnlyList<ContentWorkloadInfo> installedWorkers,
@@ -69,8 +76,9 @@ public FunctionsWorkerResolutionResult ResolveWorker(
         return FunctionsWorkerResolutionResults.Resolved(resolvedWorker);
     }
 
-    private static bool SatisfiesConstraint(NuGetVersion version, VersionRange? constraint)
-        => constraint is null || constraint.Satisfies(version);
+    private bool SatisfiesConstraint(NuGetVersion version, VersionRange? constraint)
+        => constraint is null
+            || WorkloadVersionRanges.SatisfiesRange(constraint, version, _catalogOptions.IncludePrerelease);
 
     private static FunctionsWorkerResolutionResult NotInstalled(FunctionsWorkerId workerId)
         => NotInstalledResult(

src/Func/Workloads/Catalog/WorkloadCatalog.cs

@@ -109,25 +109,6 @@ private NuGetProtocolSourceClient ResolveClient(string? source)
         return best;
     }
 
-    // NuGet's VersionRange.Satisfies rejects prerelease candidates when the
-    // range itself has no prerelease in its bounds (e.g. a range pinned to
-    // "[3.13.0]" rejects "3.13.0-preview.1" even though both share the same
-    // numeric version). When prerelease is enabled, re-check the candidate's
-    // numeric portion against the range so prerelease versions whose numeric
-    // version is inside the bounds are accepted.
     private static bool SatisfiesRange(VersionRange range, NuGetVersion candidate, bool includePrerelease)
-    {
-        if (range.Satisfies(candidate))
-        {
-            return true;
-        }
-
-        if (!includePrerelease || !candidate.IsPrerelease)
-        {
-            return false;
-        }
-
-        var numeric = new NuGetVersion(candidate.Major, candidate.Minor, candidate.Patch, candidate.Revision);
-        return range.Satisfies(numeric);
-    }
+        => WorkloadVersionRanges.SatisfiesRange(range, candidate, includePrerelease);
 }

src/Func/Workloads/Catalog/WorkloadVersionRanges.cs

@@ -0,0 +1,44 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using NuGet.Versioning;
+
+namespace Azure.Functions.Cli.Workloads.Catalog;
+
+/// <summary>
+/// Helpers for evaluating <see cref="VersionRange"/> against <see cref="NuGetVersion"/>
+/// candidates in a way that accounts for NuGet's prerelease handling.
+/// </summary>
+internal static class WorkloadVersionRanges
+{
+    /// <summary>
+    /// Returns whether <paramref name="candidate"/> satisfies <paramref name="range"/>,
+    /// honoring <paramref name="includePrerelease"/>.
+    /// </summary>
+    /// <remarks>
+    /// NuGet's <see cref="VersionRange.Satisfies(NuGetVersion)"/> rejects prerelease
+    /// candidates when the range itself has no prerelease in its bounds (for example,
+    /// a range pinned to <c>[3.13.0]</c> rejects <c>3.13.0-preview.1</c> even though
+    /// both share the same numeric version). When prerelease is enabled, re-check the
+    /// candidate's numeric portion against the range so prerelease versions whose
+    /// numeric version is inside the bounds are accepted.
+    /// </remarks>
+    public static bool SatisfiesRange(VersionRange range, NuGetVersion candidate, bool includePrerelease)
+    {
+        ArgumentNullException.ThrowIfNull(range);
+        ArgumentNullException.ThrowIfNull(candidate);
+
+        if (range.Satisfies(candidate))
+        {
+            return true;
+        }
+
+        if (!includePrerelease || !candidate.IsPrerelease)
+        {
+            return false;
+        }
+
+        var numeric = new NuGetVersion(candidate.Major, candidate.Minor, candidate.Patch, candidate.Revision);
+        return range.Satisfies(numeric);
+    }
+}

src/Func/release_notes.md

@@ -2,3 +2,5 @@
 
 #### Changes
 
+- Fix `func start` failing to resolve installed prerelease worker workloads against built-in profile ranges (e.g. `node [3.13.0]` now accepts `3.13.0-preview.1`). (#5286)
+

test/Func.Tests/Workers/DefaultFunctionsWorkerInstallerTests.cs

@@ -7,6 +7,7 @@
 using Azure.Functions.Cli.Workloads.Discovery;
 using Azure.Functions.Cli.Workloads.Install;
 using Azure.Functions.Cli.Workloads.Storage;
+using Microsoft.Extensions.Options;
 using NSubstitute;
 using NuGet.Configuration;
 using NuGet.Versioning;
@@ -181,7 +182,7 @@ await Assert.ThrowsAsync<ArgumentNullException>(
     [Fact]
     public void Ctor_NullDependencies_Throw()
     {
-        var contentResolver = new DefaultFunctionsWorkerContentResolver(_fileSystem);
+        var contentResolver = new DefaultFunctionsWorkerContentResolver(_fileSystem, Options.Create(new WorkloadCatalogOptions()));
 
         Assert.Throws<ArgumentNullException>(() => new DefaultFunctionsWorkerInstaller(null!, _workloadInstaller, _workloadPaths, contentResolver));
         Assert.Throws<ArgumentNullException>(() => new DefaultFunctionsWorkerInstaller(_workloadCatalog, null!, _workloadPaths, contentResolver));
@@ -191,7 +192,7 @@ public void Ctor_NullDependencies_Throw()
 
     private DefaultFunctionsWorkerInstaller CreateInstaller()
     {
-        var contentResolver = new DefaultFunctionsWorkerContentResolver(_fileSystem);
+        var contentResolver = new DefaultFunctionsWorkerContentResolver(_fileSystem, Options.Create(new WorkloadCatalogOptions()));
         return new DefaultFunctionsWorkerInstaller(_workloadCatalog, _workloadInstaller, _workloadPaths, contentResolver);
     }
 

test/Func.Tests/Workers/DefaultFunctionsWorkerResolverTests.cs

@@ -3,6 +3,8 @@
 
 using Azure.Functions.Cli.Workers;
 using Azure.Functions.Cli.Workloads;
+using Azure.Functions.Cli.Workloads.Catalog;
+using Microsoft.Extensions.Options;
 using NSubstitute;
 using NuGet.Versioning;
 using Xunit;
@@ -264,7 +266,52 @@ public void Ctor_NullContentResolver_Throws()
     [Fact]
     public void ContentResolverCtor_NullWorkerConfigFileSystem_Throws()
     {
-        Assert.Throws<ArgumentNullException>(() => new DefaultFunctionsWorkerContentResolver(null!));
+        Assert.Throws<ArgumentNullException>(
+            () => new DefaultFunctionsWorkerContentResolver(null!, Options.Create(new WorkloadCatalogOptions())));
+    }
+
+    [Fact]
+    public void ContentResolverCtor_NullCatalogOptions_Throws()
+    {
+        Assert.Throws<ArgumentNullException>(() => new DefaultFunctionsWorkerContentResolver(_fileSystem, null!));
+    }
+
+    [Fact]
+    public async Task ResolveWorkerAsync_ExactStableRange_ResolvesPrereleaseInstalled_WhenIncludePrereleaseTrue()
+    {
+        // Repro for issue #5286: built-in profile pins worker to exact stable [3.13.0]
+        // but the catalog/installer only has 3.13.0-preview.1 installed. The resolver
+        // must accept the prerelease when prerelease is enabled.
+        ContentWorkloadInfo preview = CreateContentWorkload(NodeWorkerPackageId, "3.13.0-preview.1");
+        UseContentWorkloads(preview);
+
+        DefaultFunctionsWorkerResolver resolver = CreateResolver(
+            new Dictionary<string, VersionRange> { ["node"] = VersionRange.Parse("[3.13.0]") },
+            includePrerelease: true);
+
+        FunctionsWorkerResolutionResult result = await resolver.ResolveWorkerAsync(
+            new FunctionsWorkerId("node"),
+            CancellationToken.None);
+
+        FunctionsWorkerResolutionResult.Resolved resolved = Assert.IsType<FunctionsWorkerResolutionResult.Resolved>(result);
+        Assert.Equal("3.13.0-preview.1", resolved.Worker.Version);
+    }
+
+    [Fact]
+    public async Task ResolveWorkerAsync_ExactStableRange_RejectsPrereleaseInstalled_WhenIncludePrereleaseFalse()
+    {
+        ContentWorkloadInfo preview = CreateContentWorkload(NodeWorkerPackageId, "3.13.0-preview.1");
+        UseContentWorkloads(preview);
+
+        DefaultFunctionsWorkerResolver resolver = CreateResolver(
+            new Dictionary<string, VersionRange> { ["node"] = VersionRange.Parse("[3.13.0]") },
+            includePrerelease: false);
+
+        FunctionsWorkerResolutionResult result = await resolver.ResolveWorkerAsync(
+            new FunctionsWorkerId("node"),
+            CancellationToken.None);
+
+        Assert.IsType<FunctionsWorkerResolutionResult.NotResolved>(result);
     }
 
     private void UseContentWorkloads(params ContentWorkloadInfo[] workloads)
@@ -280,10 +327,13 @@ private void UseContentWorkloads(params ContentWorkloadInfo[] workloads)
             });
     }
 
-    private DefaultFunctionsWorkerResolver CreateResolver(IReadOnlyDictionary<string, VersionRange>? workerVersionRanges = null)
-        => new(_workloads, CreateContentResolver(), workerVersionRanges);
+    private DefaultFunctionsWorkerResolver CreateResolver(
+        IReadOnlyDictionary<string, VersionRange>? workerVersionRanges = null,
+        bool includePrerelease = false)
+        => new(_workloads, CreateContentResolver(includePrerelease), workerVersionRanges);
 
-    private DefaultFunctionsWorkerContentResolver CreateContentResolver() => new(_fileSystem);
+    private DefaultFunctionsWorkerContentResolver CreateContentResolver(bool includePrerelease = false)
+        => new(_fileSystem, Options.Create(new WorkloadCatalogOptions { IncludePrerelease = includePrerelease }));
 
     private static ContentWorkloadInfo CreateContentWorkload(string packageId, string packageVersion, IReadOnlyList<string>? aliases = null)
     {