@spinnaker/core 2026.2.2 → 2026.3.0

package/src/pipeline/config/stages/applySourceServerGroupCapacity/applySourceServerGroupCapacityStage.module.ts

@@ -1,16 +1,13 @@
-import { module } from 'angular';
-
 import { ApplySourceServerGroupCapacityDetails } from './ApplySourceServerGroupCapacityDetails';
-import { ExecutionDetailsTasks } from '../common';
+import { ExecutionDetailsTasks, NoConfigurationStageConfig } from '../common';
+import type { IStageTypeConfig } from '../../../../domain';
 import { Registry } from '../../../../registry';
 
-export const APPLY_SOURCE_SERVER_GROUP_CAPACITY_STAGE =
-  'spinnaker.core.pipeline.stage.applySourceServerGroupCapacityStage';
+export const applySourceServerGroupCapacityStage: IStageTypeConfig = {
+  synthetic: true,
+  key: 'applySourceServerGroupCapacity',
+  component: NoConfigurationStageConfig,
+  executionDetailsSections: [ApplySourceServerGroupCapacityDetails, ExecutionDetailsTasks],
+};
 
-module(APPLY_SOURCE_SERVER_GROUP_CAPACITY_STAGE, []).config(() => {
-  Registry.pipeline.registerStage({
-    synthetic: true,
-    key: 'applySourceServerGroupCapacity',
-    executionDetailsSections: [ApplySourceServerGroupCapacityDetails, ExecutionDetailsTasks],
-  });
-});
+Registry.pipeline.registerStage(applySourceServerGroupCapacityStage);

package/src/pipeline/config/stages/bake/BakeryReader.ts

@@ -1,5 +1,4 @@
 import { get, has } from 'lodash';
-import { $q } from 'ngimport';
 
 import { AccountService } from '../../../../account/AccountService';
 import { REST } from '../../../../api/ApiService';
@@ -19,26 +18,26 @@ export interface IBaseOsOptions {
 }
 
 export class BakeryReader {
-  public static getRegions(provider: string): PromiseLike<string[]> {
+  public static getRegions(provider: string): Promise<string[]> {
     if (has(SETTINGS, `providers.${provider}.bakeryRegions`)) {
-      return $q.when(get(SETTINGS, `providers.${provider}.bakeryRegions`));
+      return Promise.resolve(get(SETTINGS, `providers.${provider}.bakeryRegions`));
     }
     return AccountService.getUniqueAttributeForAllAccounts(provider, 'regions').then((regions: string[]) =>
       regions.sort(),
     );
   }
 
-  public static getBaseOsOptions(provider: string): PromiseLike<IBaseOsOptions> {
+  public static getBaseOsOptions(provider: string): Promise<IBaseOsOptions> {
     return this.getAllBaseOsOptions().then((options) => {
       return options.find((o) => o.cloudProvider === provider);
     });
   }
 
-  private static getAllBaseOsOptions(): PromiseLike<IBaseOsOptions[]> {
+  private static getAllBaseOsOptions(): Promise<IBaseOsOptions[]> {
     return REST('/bakery/options').useCache().get();
   }
 
-  public static getBaseLabelOptions(): PromiseLike<string[]> {
-    return $q.when(['release', 'candidate', 'previous', 'unstable']);
+  public static getBaseLabelOptions(): Promise<string[]> {
+    return Promise.resolve(['release', 'candidate', 'previous', 'unstable']);
   }
 }

package/src/pipeline/config/stages/bake/bakeStage.js

@@ -1,27 +1,17 @@
-'use strict';
-
-import { module } from 'angular';
-
 import { ManualExecutionBake } from './ManualExecutionBake';
-import { CORE_PIPELINE_CONFIG_STAGES_BAKE_BAKESTAGE_TRANSFORMER } from './bakeStage.transformer';
+import { bakeStageTransformer } from './bakeStage.transformer';
+import { NoConfigurationStageConfig } from '../common';
 import { Registry } from '../../../../registry';
 
-export const CORE_PIPELINE_CONFIG_STAGES_BAKE_BAKESTAGE = 'spinnaker.core.pipeline.stage.bakeStage';
-export const name = CORE_PIPELINE_CONFIG_STAGES_BAKE_BAKESTAGE; // for backwards compatibility
-module(CORE_PIPELINE_CONFIG_STAGES_BAKE_BAKESTAGE, [CORE_PIPELINE_CONFIG_STAGES_BAKE_BAKESTAGE_TRANSFORMER])
-  .config(function () {
-    Registry.pipeline.registerStage({
-      useBaseProvider: true,
-      label: 'Bake',
-      description: 'Bakes an image',
-      key: 'bake',
-      restartable: true,
-      manualExecutionComponent: ManualExecutionBake,
-    });
-  })
-  .run([
-    'bakeStageTransformer',
-    function (bakeStageTransformer) {
-      Registry.pipeline.registerTransformer(bakeStageTransformer);
-    },
-  ]);
+export const bakeStage = {
+  useBaseProvider: true,
+  label: 'Bake',
+  description: 'Bakes an image',
+  key: 'bake',
+  component: NoConfigurationStageConfig,
+  restartable: true,
+  manualExecutionComponent: ManualExecutionBake,
+};
+
+Registry.pipeline.registerStage(bakeStage);
+Registry.pipeline.registerTransformer(bakeStageTransformer);

package/src/pipeline/config/stages/bake/bakeStage.spec.ts

@@ -0,0 +1,17 @@
+import { ManualExecutionBake } from './ManualExecutionBake';
+import { bakeStage } from './bakeStage';
+
+describe('Bake stage registration', () => {
+  it('exports the Bake stage config', () => {
+    expect(bakeStage).toEqual(
+      jasmine.objectContaining({
+        useBaseProvider: true,
+        label: 'Bake',
+        description: 'Bakes an image',
+        key: 'bake',
+        restartable: true,
+        manualExecutionComponent: ManualExecutionBake,
+      }),
+    );
+  });
+});

package/src/pipeline/config/stages/bake/bakeStage.transformer.js

@@ -1,29 +1,23 @@
-'use strict';
-
-import { module } from 'angular';
-
-export const CORE_PIPELINE_CONFIG_STAGES_BAKE_BAKESTAGE_TRANSFORMER = 'spinnaker.core.pipeline.stage.bake.transformer';
-export const name = CORE_PIPELINE_CONFIG_STAGES_BAKE_BAKESTAGE_TRANSFORMER; // for backwards compatibility
-module(CORE_PIPELINE_CONFIG_STAGES_BAKE_BAKESTAGE_TRANSFORMER, []).service('bakeStageTransformer', function () {
-  /**
-   * Bubbles "previouslyBaked" flag up to parallel bake stage
-   */
-  function propagatePreviouslyBakedFlag(execution) {
-    execution.stages.forEach(function (stage) {
-      if (stage.type === 'bake' && stage.context) {
-        const childBakeStages = execution.stages.filter(
-          (test) => test.type === 'bake' && test.parentStageId === stage.id,
-        );
-        if (childBakeStages.length) {
-          stage.context.allPreviouslyBaked = childBakeStages.every((child) => child.context.previouslyBaked);
-          stage.context.somePreviouslyBaked =
-            !stage.context.allPreviouslyBaked && childBakeStages.some((child) => child.context.previouslyBaked);
-        }
+/**
+ * Bubbles "previouslyBaked" flag up to parallel bake stage.
+ */
+function propagatePreviouslyBakedFlag(execution) {
+  execution.stages.forEach(function (stage) {
+    if (stage.type === 'bake' && stage.context) {
+      const childBakeStages = execution.stages.filter(
+        (test) => test.type === 'bake' && test.parentStageId === stage.id,
+      );
+      if (childBakeStages.length) {
+        stage.context.allPreviouslyBaked = childBakeStages.every((child) => child.context.previouslyBaked);
+        stage.context.somePreviouslyBaked =
+          !stage.context.allPreviouslyBaked && childBakeStages.some((child) => child.context.previouslyBaked);
       }
-    });
-  }
+    }
+  });
+}
 
-  this.transform = function (application, execution) {
+export const bakeStageTransformer = {
+  transform(application, execution) {
     propagatePreviouslyBakedFlag(execution);
-  };
-});
+  },
+};

package/src/pipeline/config/stages/bake/bakeStage.transformer.spec.js

@@ -1,14 +1,6 @@
-'use strict';
+import { bakeStageTransformer } from './bakeStage.transformer';
 
 describe('bakeStageTransformer', function () {
-  beforeEach(window.module(require('./bakeStage.transformer').name));
-
-  beforeEach(
-    window.inject(function (bakeStageTransformer) {
-      this.transformer = bakeStageTransformer;
-    }),
-  );
-
   describe('transform', function () {
     it('should add allPreviouslyBaked/somePreviouslyBaked flags when all/some child bake stages are marked previouslyBaked', function () {
       var execution = {
@@ -27,7 +19,7 @@ describe('bakeStageTransformer', function () {
 
       execution.stages.forEach((stage) => (stage.type = 'bake'));
 
-      this.transformer.transform({}, execution);
+      bakeStageTransformer.transform({}, execution);
 
       expect(execution.stages[0].context.allPreviouslyBaked).toBe(true);
       expect(execution.stages[0].context.somePreviouslyBaked).toBe(false);

package/src/pipeline/config/stages/bakeManifest/BakeManifestConfig.tsx

@@ -7,7 +7,18 @@ import { FormikStageConfig } from '../FormikStageConfig';
 import { HELM_RENDERERS, HELMFILE_RENDERER } from './ManifestRenderers';
 import type { IStageConfigProps } from '../common';
 import type { IExpectedArtifact, IStage } from '../../../../domain';
-import { FormValidator } from '../../../../presentation';
+import type { IValidator } from '../../../../presentation';
+import { errorMessage, FormValidator } from '../../../../presentation';
+
+// Namespace/Environment are passed as literal arguments to the helmfile CLI (e.g. `--namespace
+// <value>`) by rosco's HelmfileTemplateUtils, which executes the command as an argv array (never
+// via a shell) - so this is not a shell-injection fix. It guards against argument injection (e.g.
+// a value beginning with "-" being misread as a new CLI flag) and acts as defense-in-depth,
+// matching the equivalent validation in HelmfileTemplateUtils on the rosco side. Values containing
+// a SpEL expression are exempted here since they're resolved server-side before baking.
+const safeCliArgumentValidator: IValidator = (val: string, label: string) =>
+  !/^[a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?$/.test(val) &&
+  errorMessage(`${label} may only contain letters, numbers, '.', '_', and '-'`);
 
 export function BakeManifestConfig({ application, pipeline, stage, updateStage }: IStageConfigProps) {
   const stageWithDefaults = React.useMemo(() => {
@@ -48,6 +59,8 @@ export function validateBakeManifestStage(stage: IStage): FormikErrors<IStage> {
   }
   if (HELMFILE_RENDERER === stage.templateRenderer) {
     formValidator.field('outputName', 'Name').required();
+    formValidator.field('namespace', 'Namespace').optional().spelAware().withValidators(safeCliArgumentValidator);
+    formValidator.field('environment', 'Environment').optional().spelAware().withValidators(safeCliArgumentValidator);
   }
 
   return formValidator.validateForm();

package/src/pipeline/config/stages/bakeManifest/helm/BakeHelmConfigForm.spec.tsx

@@ -1,4 +1,3 @@
-import { mock } from 'angular';
 import { mount } from 'enzyme';
 import React from 'react';
 
@@ -9,12 +8,8 @@ import { ApplicationModelBuilder } from '../../../../../application';
 import { ExpectedArtifactService } from '../../../../../artifact';
 import type { IExpectedArtifact, IStage } from '../../../../../domain';
 import { SpinFormik } from '../../../../../presentation';
-import { REACT_MODULE } from '../../../../../reactShims';
 
 describe('<BakeHelmConfigForm />', () => {
-  beforeEach(mock.module(REACT_MODULE));
-  beforeEach(mock.inject());
-
   const helmChartFilePathFieldName = 'Helm Chart File Path';
 
   const getProps = () => {

package/src/pipeline/config/stages/bakeManifest/helmfile/BakeHelmfileConfigForm.spec.tsx

@@ -1,4 +1,3 @@
-import { mock } from 'angular';
 import { mount } from 'enzyme';
 import React from 'react';
 
@@ -9,12 +8,8 @@ import { ApplicationModelBuilder } from '../../../../../application';
 import { ExpectedArtifactService } from '../../../../../artifact';
 import type { IExpectedArtifact, IStage } from '../../../../../domain';
 import { SpinFormik } from '../../../../../presentation';
-import { REACT_MODULE } from '../../../../../reactShims';
 
 describe('<BakeHelmfileConfigForm />', () => {
-  beforeEach(mock.module(REACT_MODULE));
-  beforeEach(mock.inject());
-
   const helmfileFilePathFieldName = 'Helmfile File Path';
 
   const getProps = () => {

package/src/pipeline/config/stages/bakeManifest/helmfile/BakeHelmfileConfigForm.tsx

@@ -127,6 +127,42 @@ export class BakeHelmfileConfigForm extends React.Component<
     }
   };
 
+  private onStateValuesArtifactEdited = (artifact: IArtifact, index: number) => {
+    this.props.formik.setFieldValue(`stateValuesArtifacts[${index}].id`, null);
+    this.props.formik.setFieldValue(`stateValuesArtifacts[${index}].artifact`, artifact);
+    this.props.formik.setFieldValue(`stateValuesArtifacts[${index}].account`, artifact.artifactAccount);
+  };
+
+  private onStateValuesArtifactSelected = (artifact: IExpectedArtifact, index: number) => {
+    this.props.formik.setFieldValue(`stateValuesArtifacts[${index}].id`, artifact.id);
+    this.props.formik.setFieldValue(`stateValuesArtifacts[${index}].artifact`, null);
+    if (artifact.matchArtifact) {
+      this.props.formik.setFieldValue(`stateValuesArtifacts[${index}].account`, artifact.matchArtifact.artifactAccount);
+    } else {
+      this.props.formik.setFieldValue(`stateValuesArtifacts[${index}].account`, null);
+    }
+  };
+
+  private addStateValuesArtifact = () => {
+    const stage = this.props.formik.values;
+    const newStateValuesArtifacts = [
+      ...(stage.stateValuesArtifacts || []),
+      {
+        account: '',
+        id: '',
+      },
+    ];
+
+    this.props.formik.setFieldValue('stateValuesArtifacts', newStateValuesArtifacts);
+  };
+
+  private removeStateValuesArtifact = (index: number) => {
+    const stage = this.props.formik.values;
+    const newStateValuesArtifacts = [...stage.stateValuesArtifacts];
+    newStateValuesArtifacts.splice(index, 1);
+    this.props.formik.setFieldValue('stateValuesArtifacts', newStateValuesArtifacts);
+  };
+
   private outputNameChange = (outputName: string) => {
     const stage = this.props.formik.values;
     const expectedArtifacts = stage.expectedArtifacts;
@@ -166,6 +202,30 @@ export class BakeHelmfileConfigForm extends React.Component<
             value={stage.outputName}
           />
         </StageConfigField>
+        <StageConfigField
+          fieldColumns={3}
+          label={'Namespace'}
+          helpKey="pipeline.config.bake.manifest.helmfile.namespace"
+        >
+          <TextInput
+            onChange={(e: React.ChangeEvent<any>) => {
+              this.props.formik.setFieldValue('namespace', e.target.value);
+            }}
+            value={stage.namespace}
+          />
+        </StageConfigField>
+        <StageConfigField
+          fieldColumns={3}
+          label={'Environment'}
+          helpKey="pipeline.config.bake.manifest.helmfile.environment"
+        >
+          <TextInput
+            onChange={(e: React.ChangeEvent<any>) => {
+              this.props.formik.setFieldValue('environment', e.target.value);
+            }}
+            value={stage.environment}
+          />
+        </StageConfigField>
         <h4>Template Artifact</h4>
         <StageArtifactSelectorDelegate
           artifact={this.getInputArtifact(stage, 0).artifact}
@@ -231,6 +291,47 @@ export class BakeHelmfileConfigForm extends React.Component<
             Add value artifact
           </button>
         </StageConfigField>
+        <h4>State Values</h4>
+        {stage.stateValuesArtifacts && stage.stateValuesArtifacts.length > 0 && (
+          <div className="row form-group">
+            {stage.stateValuesArtifacts.map((a: any, index: number) => {
+              return (
+                <div key={index}>
+                  <div className="col-md-offset-1 col-md-9">
+                    <StageArtifactSelectorDelegate
+                      artifact={a.artifact}
+                      excludedArtifactTypePatterns={[]}
+                      expectedArtifactId={a.id}
+                      label="Expected Artifact"
+                      onArtifactEdited={(artifact) => {
+                        this.onStateValuesArtifactEdited(artifact, index);
+                      }}
+                      onExpectedArtifactSelected={(artifact: IExpectedArtifact) =>
+                        this.onStateValuesArtifactSelected(artifact, index)
+                      }
+                      pipeline={this.props.pipeline}
+                      stage={stage}
+                    />
+                  </div>
+                  <div className="col-md-1">
+                    <div className="form-control-static">
+                      <button onClick={() => this.removeStateValuesArtifact(index)}>
+                        <span className="glyphicon glyphicon-trash" />
+                        <span className="sr-only">Remove field</span>
+                      </button>
+                    </div>
+                  </div>
+                </div>
+              );
+            })}
+          </div>
+        )}
+        <StageConfigField fieldColumns={8} label={''} helpKey="pipeline.config.bake.manifest.helmfile.stateValues">
+          <button className="btn btn-block btn-sm add-new" onClick={() => this.addStateValuesArtifact()}>
+            <span className="glyphicon glyphicon-plus-sign" />
+            Add state values artifact
+          </button>
+        </StageConfigField>
         <StageConfigField fieldColumns={6} label="Overrides">
           {stage.overrides && (
             <MapEditor

package/src/pipeline/config/stages/baseProviderStage/BaseProviderStageConfig.spec.tsx

@@ -0,0 +1,120 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { CloudProviderLabel, CloudProviderLogo } from '../../../../cloudProvider';
+import { ReactSelectInput } from '../../../../presentation';
+import { BaseProviderStageConfig } from './BaseProviderStageConfig';
+
+describe('BaseProviderStageConfig', () => {
+  it('renders nothing when no providers are available', () => {
+    const wrapper = mount(
+      <BaseProviderStageConfig providers={[]} readOnly={false} onProviderChange={jasmine.createSpy()} />,
+    );
+
+    expect(wrapper.isEmptyRender()).toBe(true);
+
+    wrapper.unmount();
+  });
+
+  it('renders and selects the only provider once from an effect', () => {
+    const onProviderChange = jasmine.createSpy('onProviderChange');
+    const providers = ['ecs'];
+    const wrapper = mount(
+      <BaseProviderStageConfig providers={providers} readOnly={false} onProviderChange={onProviderChange} />,
+    );
+
+    wrapper.setProps({ providers });
+    wrapper.update();
+
+    expect(wrapper.find(CloudProviderLogo).prop('provider')).toBe('ecs');
+    expect(wrapper.find(CloudProviderLabel).prop('provider')).toBe('ecs');
+    expect(wrapper.find('.base-provider-label').text()).toBe('EC2 Container Service');
+    expect(onProviderChange).toHaveBeenCalledTimes(1);
+    expect(onProviderChange).toHaveBeenCalledWith('ecs');
+
+    wrapper.unmount();
+  });
+
+  it('auto-selects the same sole provider again when a controlled parent changes stages and clears selection', () => {
+    const onProviderChange = jasmine.createSpy('onProviderChange');
+
+    const ControlledSelector = ({ stageId }: { stageId: string }) => {
+      const [selectedProvider, setSelectedProvider] = React.useState<string>();
+      React.useEffect(() => setSelectedProvider(undefined), [stageId]);
+      return (
+        <BaseProviderStageConfig
+          providers={['ecs']}
+          selectedProvider={selectedProvider}
+          readOnly={false}
+          onProviderChange={(provider) => {
+            onProviderChange(stageId, provider);
+            setSelectedProvider(provider);
+          }}
+        />
+      );
+    };
+
+    const wrapper = mount(<ControlledSelector stageId="1" />);
+
+    expect(onProviderChange).toHaveBeenCalledTimes(1);
+    expect(onProviderChange).toHaveBeenCalledWith('1', 'ecs');
+
+    wrapper.setProps({ stageId: '2' });
+    wrapper.update();
+
+    expect(onProviderChange).toHaveBeenCalledTimes(2);
+    expect(onProviderChange).toHaveBeenCalledWith('2', 'ecs');
+
+    wrapper.unmount();
+  });
+
+  it('renders an editable provider select and emits its selected value', () => {
+    const onProviderChange = jasmine.createSpy('onProviderChange');
+    const wrapper = mount(
+      <BaseProviderStageConfig providers={['aws', 'ecs']} readOnly={false} onProviderChange={onProviderChange} />,
+    );
+
+    const select = wrapper.find(ReactSelectInput);
+    expect(select.prop('name')).toBe('cloudProviderType');
+    expect(select.prop('options')).toEqual([
+      { label: 'aws', value: 'aws' },
+      { label: 'ecs', value: 'ecs' },
+    ]);
+
+    select.prop('onChange')({ target: { value: 'ecs' } } as any);
+
+    expect(onProviderChange).toHaveBeenCalledOnceWith('ecs');
+
+    wrapper.unmount();
+  });
+
+  it('renders the selected provider without an editable select when read-only', () => {
+    const wrapper = mount(
+      <BaseProviderStageConfig
+        providers={['aws', 'ecs']}
+        selectedProvider="ecs"
+        readOnly={true}
+        onProviderChange={jasmine.createSpy()}
+      />,
+    );
+
+    expect(wrapper.find(ReactSelectInput).exists()).toBe(false);
+    expect(wrapper.find(CloudProviderLogo).prop('provider')).toBe('ecs');
+    expect(wrapper.find(CloudProviderLabel).prop('provider')).toBe('ecs');
+
+    wrapper.unmount();
+  });
+
+  it('does not auto-select a sole provider when read-only', () => {
+    const onProviderChange = jasmine.createSpy('onProviderChange');
+    const wrapper = mount(
+      <BaseProviderStageConfig providers={['ecs']} readOnly={true} onProviderChange={onProviderChange} />,
+    );
+
+    expect(wrapper.find(ReactSelectInput).exists()).toBe(false);
+    expect(wrapper.find(CloudProviderLogo).prop('provider')).toBe('ecs');
+    expect(onProviderChange).not.toHaveBeenCalled();
+
+    wrapper.unmount();
+  });
+});

package/src/pipeline/config/stages/baseProviderStage/BaseProviderStageConfig.tsx

@@ -0,0 +1,63 @@
+import React from 'react';
+
+import { CloudProviderLabel, CloudProviderLogo } from '../../../../cloudProvider';
+import { StageConfigField } from '../common/stageConfigField/StageConfigField';
+import { ReactSelectInput } from '../../../../presentation';
+
+export interface IBaseProviderStageConfigProps {
+  providers: string[];
+  selectedProvider?: string;
+  readOnly: boolean;
+  onProviderChange(provider: string): void;
+}
+
+const Provider = ({ provider }: { provider: string }) => (
+  <span>
+    <CloudProviderLogo provider={provider} height="14px" width="14px" />{' '}
+    <span className="base-provider-label">
+      <CloudProviderLabel provider={provider} />
+    </span>
+  </span>
+);
+
+export function BaseProviderStageConfig({
+  providers,
+  selectedProvider,
+  readOnly,
+  onProviderChange,
+}: IBaseProviderStageConfigProps) {
+  React.useEffect(() => {
+    if (!readOnly && providers.length === 1 && !selectedProvider) {
+      onProviderChange(providers[0]);
+    }
+  }, [onProviderChange, providers, readOnly, selectedProvider]);
+
+  if (!providers.length) {
+    return null;
+  }
+
+  const displayedProvider = selectedProvider || (providers.length === 1 ? providers[0] : undefined);
+
+  return (
+    <StageConfigField label="Provider">
+      {readOnly || providers.length === 1 ? (
+        displayedProvider && (
+          <p className="form-control-static">
+            <Provider provider={displayedProvider} />
+          </p>
+        )
+      ) : (
+        <ReactSelectInput
+          clearable={false}
+          name="cloudProviderType"
+          onChange={(event) => onProviderChange(event.target.value)}
+          optionRenderer={(option: any) => <Provider provider={option.value} />}
+          options={providers.map((provider) => ({ label: provider, value: provider }))}
+          placeholder="Select a provider"
+          value={selectedProvider || ''}
+          valueRenderer={(option: any) => <Provider provider={option.value} />}
+        />
+      )}
+    </StageConfigField>
+  );
+}

package/src/pipeline/config/stages/checkPreconditions/CheckPreconditionsStageConfig.spec.tsx

@@ -0,0 +1,73 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { PreconditionList } from '../../preconditions/PreconditionList';
+import { CheckPreconditionsStageConfig } from './CheckPreconditionsStageConfig';
+
+describe('<CheckPreconditionsStageConfig />', () => {
+  const createProps = (stageOverrides = {}, pipelineOverrides = {}) => {
+    const parentStage: any = {
+      name: 'Bake',
+      refId: '1',
+      requisiteStageRefIds: [],
+      type: 'bake',
+    };
+    const stage: any = {
+      name: 'Check Preconditions',
+      refId: '2',
+      requisiteStageRefIds: ['1'],
+      type: 'checkPreconditions',
+      ...stageOverrides,
+    };
+    const pipeline: any = {
+      stages: [parentStage, stage],
+      strategy: false,
+      ...pipelineOverrides,
+    };
+
+    return {
+      application: {} as any,
+      pipeline,
+      stage,
+      stageFieldUpdated: jasmine.createSpy('stageFieldUpdated'),
+      updateStage: jasmine.createSpy('updateStage'),
+      updateStageField: jasmine
+        .createSpy('updateStageField')
+        .and.callFake((changes: any) => Object.assign(stage, changes)),
+    };
+  };
+
+  it('passes an empty precondition list without mutating the stage during render', () => {
+    const props = createProps();
+
+    const component = mount(<CheckPreconditionsStageConfig {...props} />);
+
+    expect(props.stage.preconditions).toBeUndefined();
+    expect(component.find(PreconditionList).prop('preconditions')).toEqual([]);
+    expect(props.updateStageField).not.toHaveBeenCalled();
+    expect(props.stageFieldUpdated).not.toHaveBeenCalled();
+  });
+
+  it('renders the precondition list with strategy and upstream stages', () => {
+    const preconditions = [{ context: { expression: '${true}' }, failPipeline: true, type: 'expression' }];
+    const props = createProps({ preconditions }, { strategy: true });
+    const component = mount(<CheckPreconditionsStageConfig {...props} />);
+
+    const preconditionList = component.find(PreconditionList);
+
+    expect(preconditionList.prop('application')).toBe(props.application);
+    expect(preconditionList.prop('preconditions')).toBe(preconditions);
+    expect(preconditionList.prop('strategy')).toBe(true);
+    expect(preconditionList.prop('upstreamStages')).toEqual([props.pipeline.stages[0]]);
+  });
+
+  it('updates stage preconditions through updateStageField', () => {
+    const props = createProps({ preconditions: [] });
+    const component = mount(<CheckPreconditionsStageConfig {...props} />);
+    const updatedPreconditions = [{ context: { expression: '${true}' }, failPipeline: true, type: 'expression' }];
+
+    component.find(PreconditionList).prop('onChange')(updatedPreconditions as any);
+
+    expect(props.updateStageField).toHaveBeenCalledWith({ preconditions: updatedPreconditions });
+  });
+});