Preselect multi-select wizard step options when configured (#2023)

Fixes OPS-3797.

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: cezudas

packages/react-ui/src/app/features/benchmark/use-benchmark-wizard-navigation.test.ts

@@ -168,6 +168,47 @@ describe('useBenchmarkWizardNavigation', () => {
       expect(result.current.currentSelections).toEqual([]);
     });
 
+    it('should initialize selections from preselectedOptions when step has pre-selected options', async () => {
+      const stepResponse = buildStepResponse({
+        selectionType: 'multi-select',
+        preselectedOptions: ['us-east-1'],
+      });
+      mockGetWizardStep.mockResolvedValue(stepResponse);
+
+      const { result } = renderHook(() =>
+        useBenchmarkWizardNavigation(connectedProviders),
+      );
+
+      act(() => {
+        result.current.setSelectedProvider('aws');
+      });
+
+      await act(async () => {
+        await result.current.handleNextFromInitial();
+      });
+
+      expect(result.current.currentSelections).toEqual(['us-east-1']);
+    });
+
+    it('should initialize selections to empty array when step has no preselectedOptions', async () => {
+      const stepResponse = buildStepResponse({ preselectedOptions: undefined });
+      mockGetWizardStep.mockResolvedValue(stepResponse);
+
+      const { result } = renderHook(() =>
+        useBenchmarkWizardNavigation(connectedProviders),
+      );
+
+      act(() => {
+        result.current.setSelectedProvider('aws');
+      });
+
+      await act(async () => {
+        await result.current.handleNextFromInitial();
+      });
+
+      expect(result.current.currentSelections).toEqual([]);
+    });
+
     it('should reset selections and history when fetching first step', async () => {
       const firstStepResponse = buildStepResponse({ currentStep: 'region' });
       const secondStepResponse = buildStepResponse({
@@ -286,6 +327,37 @@ describe('useBenchmarkWizardNavigation', () => {
       expect(result.current.currentSelections).toEqual([]);
     });
 
+    it('should initialize next step selections from preselectedOptions', async () => {
+      const firstStep = buildStepResponse({
+        currentStep: 'region',
+        nextStep: 'instance-type',
+      });
+      const secondStep = buildStepResponse({
+        currentStep: 'instance-type',
+        nextStep: 'confirm',
+        selectionType: 'multi-select',
+        preselectedOptions: ['t3.medium', 't3.large'],
+      });
+      mockGetWizardStep
+        .mockResolvedValueOnce(firstStep)
+        .mockResolvedValueOnce(secondStep);
+
+      const { result } = renderHook(() =>
+        useBenchmarkWizardNavigation(connectedProviders),
+      );
+
+      act(() => result.current.setSelectedProvider('aws'));
+      await act(async () => await result.current.handleNextFromInitial());
+
+      act(() => result.current.setCurrentSelections(['us-east-1']));
+      await act(async () => await result.current.handleNextFromProviderStep());
+
+      expect(result.current.currentSelections).toEqual([
+        't3.medium',
+        't3.large',
+      ]);
+    });
+
     it('should accumulate history across multiple steps', async () => {
       const regionStep = buildStepResponse({
         currentStep: 'region',

packages/react-ui/src/app/features/benchmark/use-benchmark-wizard-navigation.ts

@@ -92,7 +92,7 @@ export const useBenchmarkWizardNavigation = (
       request: {},
     });
     setCurrentStepResponse(stepResponse);
-    setCurrentSelections([]);
+    setCurrentSelections(stepResponse.preselectedOptions ?? []);
     setStepHistory([]);
     setWizardPhase('provider-step');
   };
@@ -127,7 +127,7 @@ export const useBenchmarkWizardNavigation = (
 
     setStepHistory(newHistory);
     setCurrentStepResponse(nextStepResponse);
-    setCurrentSelections([]);
+    setCurrentSelections(nextStepResponse.preselectedOptions ?? []);
   };
 
   const handleEditSetup = () => {

packages/server/api/src/app/benchmark/provider-adapter.ts

@@ -35,6 +35,7 @@ export type WizardConfigStep = {
   optionsSource?: WizardStepOptionsSource;
   nextStep?: string;
   conditional?: WizardStepConditional;
+  selectAll?: boolean;
 };
 
 export type WizardConfig = {

packages/server/api/src/app/benchmark/providers/aws/aws.json

@@ -38,6 +38,7 @@
       "id": "workflows",
       "title": "Which AWS workflows should we run to analyze the data?",
       "selectionType": "multi-select",
+      "selectAll": true,
       "optionsSource": {
         "type": "static",
         "values": [

packages/server/api/src/app/benchmark/wizard.service.ts

@@ -160,6 +160,17 @@ export async function resolveWizardNavigation(
 
   const { totalSteps, stepIndex } = getStepProgress(config, stepToShow);
 
+  if (stepToShow.selectAll && stepToShow.selectionType !== 'multi-select') {
+    throwValidationError(
+      `Step "${stepToShow.id}" has selectAll: true but selectionType is not "multi-select".`,
+    );
+  }
+
+  const preselectedOptions =
+    stepToShow.selectAll && options.length > 0
+      ? options.map((o) => o.id)
+      : undefined;
+
   return {
     currentStep: stepToShow.id,
     title: stepToShow.title,
@@ -169,5 +180,6 @@ export async function resolveWizardNavigation(
     options,
     totalSteps,
     stepIndex,
+    preselectedOptions,
   };
 }

packages/server/api/test/unit/benchmark/wizard.service.test.ts

@@ -233,6 +233,118 @@ describe('resolveWizardNavigation', () => {
     );
   });
 
+  describe('selectAll', () => {
+    it('returns preselectedOptions with all option ids when selectAll is true and options exist', async () => {
+      const selectAllConfig = {
+        provider: 'selectall',
+        steps: [
+          {
+            id: 'step1',
+            title: 'Pick all',
+            selectionType: 'multi-select' as const,
+            selectAll: true,
+            optionsSource: {
+              type: 'static' as const,
+              values: [
+                { id: 'opt1', displayName: 'Option 1' },
+                { id: 'opt2', displayName: 'Option 2' },
+              ],
+            },
+          },
+        ],
+      };
+      const selectAllAdapter: ProviderAdapter = {
+        config: selectAllConfig,
+        resolveOptions: mockResolveOptions,
+        evaluateCondition: mockEvaluateCondition,
+      };
+      adapters.set('selectall', selectAllAdapter);
+
+      try {
+        const result = await resolveWizardNavigation(
+          'selectall',
+          {},
+          TEST_PROJECT_ID,
+        );
+        expect(result.preselectedOptions).toEqual(['opt1', 'opt2']);
+      } finally {
+        adapters.delete('selectall');
+      }
+    });
+
+    it('returns preselectedOptions as undefined when selectAll is true but options are empty', async () => {
+      const selectAllEmptyConfig = {
+        provider: 'selectall-empty',
+        steps: [
+          {
+            id: 'step1',
+            title: 'Pick all',
+            selectionType: 'multi-select' as const,
+            selectAll: true,
+            optionsSource: { type: 'dynamic' as const, method: 'listOptions' },
+          },
+        ],
+      };
+      mockResolveOptions.mockResolvedValue([]);
+      const selectAllEmptyAdapter: ProviderAdapter = {
+        config: selectAllEmptyConfig,
+        resolveOptions: mockResolveOptions,
+        evaluateCondition: mockEvaluateCondition,
+      };
+      adapters.set('selectall-empty', selectAllEmptyAdapter);
+
+      try {
+        const result = await resolveWizardNavigation(
+          'selectall-empty',
+          {},
+          TEST_PROJECT_ID,
+        );
+        expect(result.preselectedOptions).toBeUndefined();
+      } finally {
+        adapters.delete('selectall-empty');
+      }
+    });
+
+    it('returns preselectedOptions as undefined when selectAll is not set', async () => {
+      const result = await resolveWizardNavigation('test', {}, TEST_PROJECT_ID);
+      expect(result.preselectedOptions).toBeUndefined();
+    });
+
+    it('throws a validation error when selectAll is true but selectionType is single', async () => {
+      const invalidConfig = {
+        provider: 'selectall-single',
+        steps: [
+          {
+            id: 'step1',
+            title: 'Pick one',
+            selectionType: 'single' as const,
+            selectAll: true,
+            optionsSource: {
+              type: 'static' as const,
+              values: [{ id: 'opt1', displayName: 'Option 1' }],
+            },
+          },
+        ],
+      };
+
+      const invalidAdapter: ProviderAdapter = {
+        config: invalidConfig,
+        resolveOptions: mockResolveOptions,
+        evaluateCondition: mockEvaluateCondition,
+      };
+
+      adapters.set('selectall-single', invalidAdapter);
+
+      try {
+        await expect(
+          resolveWizardNavigation('selectall-single', {}, TEST_PROJECT_ID),
+        ).rejects.toThrow();
+      } finally {
+        adapters.delete('selectall-single');
+      }
+    });
+  });
+
   it('throws when conditional step is not last step and onFailure.skipToStep is not set', async () => {
     mockEvaluateCondition.mockResolvedValue(false);
     const misconfigConfig = {

packages/shared/src/lib/benchmark/dto/wizard-response.ts

@@ -21,6 +21,7 @@ export const BenchmarkWizardStepResponse = Type.Object({
   options: Type.Array(BenchmarkWizardOption),
   stepIndex: Type.Number(),
   totalSteps: Type.Number(),
+  preselectedOptions: Type.Optional(Type.Array(Type.String())),
 });
 
 export type BenchmarkWizardStepResponse = Static<