Show quickpicks if there are multiple runtime matches for targetFramework

src/commands/createNewProject/dotnetSteps/DotnetRuntimeStep.ts

@@ -16,9 +16,17 @@ export class DotnetRuntimeStep extends AzureWizardPromptStep<IProjectWizardConte
     public static async createStep(context: IProjectWizardContext): Promise<DotnetRuntimeStep> {
         if (context.targetFramework) {
             context.targetFramework = typeof context.targetFramework === 'string' ? [context.targetFramework] : context.targetFramework;
-            const runtimes = await getRuntimes(context);
+            const runtimes = (await getRuntimes(context))
             // if a targetFramework was provided from createNewProject
-            const workerRuntime = runtimes.find(runtime => context.targetFramework?.includes(runtime.targetFramework));
+            const filteredRuntimes = runtimes.filter(runtime => context.targetFramework?.includes(runtime.targetFramework));
+            let workerRuntime: cliFeedUtils.IWorkerRuntime | undefined = undefined;
+            if (filteredRuntimes.length > 1) {
+                const placeHolder: string = localize('selectWorkerRuntime', 'Select a .NET runtime');
+                workerRuntime = (await context.ui.showQuickPick(new DotnetRuntimeStep().getPicks(context, filteredRuntimes), { placeHolder })).data;
+            } else if (filteredRuntimes.length === 1) {
+                workerRuntime = filteredRuntimes[0];
+            }
+
             if (!workerRuntime) {
                 throw new Error(localize('unknownFramework', 'Unrecognized target frameworks: "{0}". Available frameworks: {1}.',
                     context.targetFramework.map(tf => `"${tf}"`).join(', '),
@@ -49,8 +57,11 @@ export class DotnetRuntimeStep extends AzureWizardPromptStep<IProjectWizardConte
         return !context.workerRuntime;
     }
 
-    private async getPicks(context: IProjectWizardContext): Promise<IAzureQuickPickItem<cliFeedUtils.IWorkerRuntime | undefined>[]> {
-        const runtimes = await getRuntimes(context);
+    private async getPicks(context: IProjectWizardContext, runtimes?: cliFeedUtils.IWorkerRuntime[]): Promise<IAzureQuickPickItem<cliFeedUtils.IWorkerRuntime | undefined>[]> {
+        if (!runtimes) {
+            runtimes = await getRuntimes(context);
+        }
+
         const picks: IAzureQuickPickItem<cliFeedUtils.IWorkerRuntime | undefined>[] = [];
         for (const runtime of runtimes) {
             picks.push({

test/MockIProjectWizardContext.ts

@@ -0,0 +1,45 @@
+/* eslint-disable no-restricted-imports */
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.md in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+
+import { type TestUserInput } from "@microsoft/vscode-azext-dev";
+import { type Uri, type WorkspaceFolder } from "vscode";
+import { type FuncVersion, type TemplateSchemaVersion } from "../extension.bundle";
+import { type OpenBehavior } from "../src/commands/createNewProject/IProjectWizardContext";
+import { type ProjectLanguage } from "../src/constants";
+import { type cliFeedUtils } from "../src/utils/cliFeedUtils";
+
+export interface MockIProjectWizardContext {
+    projectPath: string;
+    workspacePath: string;
+    workspaceFolder: WorkspaceFolder | undefined;
+
+    language?: ProjectLanguage;
+    languageModel?: number;
+    languageFilter?: RegExp;
+
+    version: FuncVersion;
+    templateSchemaVersion?: TemplateSchemaVersion;
+    projectTemplateKey: string | undefined;
+    workerRuntime?: cliFeedUtils.IWorkerRuntime;
+    openBehavior?: OpenBehavior;
+
+    generateFromOpenAPI?: boolean;
+    openApiSpecificationFile?: Uri[];
+
+    targetFramework?: string | string[];
+
+    containerizedProject?: boolean;
+
+    telemetry: {
+        properties: { [key: string]: string | undefined; }
+        measurements: { [key: string]: number | undefined; }
+    };
+    errorHandling: {
+        issueProperties: {}
+    };
+    valuesToMask: string[];
+    ui: TestUserInput;
+}

test/api.test.ts

@@ -7,11 +7,11 @@ import { runWithInputs } from '@microsoft/vscode-azext-dev';
 import { type apiUtils } from "@microsoft/vscode-azext-utils";
 import * as path from 'path';
 import { extensions, type Extension } from "vscode";
-import { ProjectLanguage, extensionId, nonNullValue, registerOnActionStartHandler } from '../extension.bundle';
+import { FuncVersion, ProjectLanguage, extensionId, nonNullValue, registerOnActionStartHandler } from '../extension.bundle';
 // eslint-disable-next-line no-restricted-imports
 import { type AzureFunctionsExtensionApi } from '../src/vscode-azurefunctions.api';
 import { getTestWorkspaceFolder, testFolderPath } from './global.test';
-import { getJavaScriptValidateOptions, validateProject, type IValidateProjectOptions } from './project/validateProject';
+import { getCSharpValidateOptions, getJavaScriptValidateOptions, validateProject, type IValidateProjectOptions } from './project/validateProject';
 
 suite(`AzureFunctionsExtensionApi`, () => {
     let api: AzureFunctionsExtensionApi;
@@ -73,4 +73,46 @@ suite(`AzureFunctionsExtensionApi`, () => {
         );
         await validateProject(folderPath, validateOptions);
     });
+
+    test('createFunction dotnet with targetFramework', async () => {
+        const functionName: string = 'endpoint1';
+        const language: string = ProjectLanguage.CSharp;
+        const workspaceFolder = getTestWorkspaceFolder();
+        const projectSubpath = 'api';
+        const folderPath: string = path.join(workspaceFolder, projectSubpath);
+
+        await runWithInputs('api.createFunction', [language, /6/i, 'Company.Function', 'Anonymous'], registerOnActionStartHandler, async () => {
+            await api.createFunction({
+                folderPath,
+                functionName,
+                templateId: 'HttpTrigger',
+                languageFilter: /^C\#$/i,
+                functionSettings: { authLevel: 'anonymous' },
+                targetFramework: ['net8.0', 'net7.0', 'net6.0']
+            });
+        });
+
+        const validateOptions: IValidateProjectOptions = getCSharpValidateOptions('net6.0', FuncVersion.v4);
+        await validateProject(folderPath, validateOptions);
+    });
+
+    // When passing in a language version that is not in the target framework the last two inputs should not be prompted if they are this test will fail
+    test('createFunction with language not in targetFramework', async () => {
+        const functionName: string = 'endpoint1';
+        const language: string = ProjectLanguage.CSharp;
+        const workspaceFolder = getTestWorkspaceFolder();
+        const projectSubpath = 'api';
+        const folderPath: string = path.join(workspaceFolder, projectSubpath);
+
+        await runWithInputs('api.createFunction', [language, /8/i], registerOnActionStartHandler, async () => {
+            await api.createFunction({
+                folderPath,
+                functionName,
+                templateId: 'HttpTrigger',
+                languageFilter: /^C\#$/i,
+                functionSettings: { authLevel: 'anonymous' },
+                targetFramework: ['net7.0', 'net6.0']
+            })
+        });
+    });
 });