@spinnaker/core 2026.2.2 → 2026.3.0

package/src/pipeline/config/PipelineRegistry.ts

@@ -38,6 +38,13 @@ export class PipelineRegistry {
     );
   }
 
+  private clearStageConfigCache(): void {
+    const getStageConfig = this.getStageConfig as typeof this.getStageConfig & {
+      cache?: { clear?: () => void };
+    };
+    getStageConfig.cache?.clear?.();
+  }
+
   private normalizeStageTypes(): void {
     this.stageTypes
       .filter((stageType) => {
@@ -54,15 +61,15 @@ export class PipelineRegistry {
           stageType.manualExecutionComponent = stageType.manualExecutionComponent || parent.manualExecutionComponent;
 
           // Optional parameters
-          if (parent.executionDetailsUrl && !stageType.executionDetailsUrl) {
-            stageType.executionDetailsUrl = parent.executionDetailsUrl;
-          }
-          if (parent.executionConfigSections && !stageType.executionConfigSections) {
-            stageType.executionConfigSections = parent.executionConfigSections;
-          }
           if (parent.executionDetailsSections && !stageType.executionDetailsSections) {
             stageType.executionDetailsSections = parent.executionDetailsSections;
           }
+          if (parent.executionDetailsComponent && !stageType.executionDetailsComponent) {
+            stageType.executionDetailsComponent = parent.executionDetailsComponent;
+          }
+          if (parent.executionStepLabelComponent && !stageType.executionStepLabelComponent) {
+            stageType.executionStepLabelComponent = parent.executionStepLabelComponent;
+          }
         }
       });
   }
@@ -91,6 +98,12 @@ export class PipelineRegistry {
     }
     this.stageTypes.push(stageConfig);
     this.normalizeStageTypes();
+    this.clearStageConfigCache();
+  }
+
+  public unregisterStage(stageConfig: IStageTypeConfig): void {
+    this.stageTypes = this.stageTypes.filter((registeredStage) => registeredStage !== stageConfig);
+    this.clearStageConfigCache();
   }
 
   /**
@@ -329,13 +342,21 @@ export class PipelineRegistry {
         // More than one stage definition matched the stage's 'type' field.
         // Try to narrow it down by cloud provider.
         const provider = PipelineRegistry.resolveCloudProvider(stage);
-        const matchesThisCloudProvider = matches.find((stageType) => stageType.cloudProvider === provider);
-        const matchesAnyCloudProvider = matches.find((stageType) => !!stageType.cloudProvider);
+        const matchesThisCloudProvider = matches.find((stageType) =>
+          PipelineRegistry.providesForCloudProvider(stageType, provider),
+        );
+        const matchesAnyCloudProvider = matches.find(
+          (stageType) => !!stageType.cloudProvider || !!stageType.providesFor?.length,
+        );
         return matchesThisCloudProvider ?? matchesAnyCloudProvider ?? matches[0];
       }
     }
   }
 
+  private static providesForCloudProvider(stage: IStageTypeConfig, provider: string): boolean {
+    return stage.cloudProvider === provider || stage.providesFor?.includes(provider) === true;
+  }
+
   // IStage doesn't have a cloudProvider field yet many stage configs are setting it.
   // Some stages (RunJob, ?) are only setting the cloudProvider field in stage.context.
   private static resolveCloudProvider(stage: IStage): string {

package/src/pipeline/config/TargetSelect.tsx

@@ -0,0 +1,79 @@
+import React from 'react';
+
+import type { IStageConstant } from './stages/stageConstants';
+
+export interface ITargetSelectProps {
+  options: IStageConstant[];
+  model: { target: string };
+  onChange(target: string): void;
+}
+
+export function TargetSelect(props: ITargetSelectProps) {
+  const [isOpen, setIsOpen] = React.useState(false);
+  const [search, setSearch] = React.useState('');
+  const [selectedTarget, setSelectedTarget] = React.useState(props.model.target);
+  const selectedOption = props.options.find((option) => option.val === selectedTarget);
+  const normalizedSearch = search.toLowerCase();
+  const filteredOptions = props.options.filter((option) => {
+    return [option.label, option.description].some((value) => (value || '').toLowerCase().includes(normalizedSearch));
+  });
+
+  const onChange = (target: string) => {
+    props.model.target = target;
+    setSelectedTarget(target);
+    props.onChange && props.onChange(target);
+    setSearch('');
+    setIsOpen(false);
+  };
+
+  return React.createElement(
+    'div',
+    {
+      className: 'target-select',
+    },
+    React.createElement('input', {
+      'aria-autocomplete': 'list',
+      'aria-expanded': isOpen,
+      className: 'form-control input-sm target-select-search',
+      onChange: (event: React.ChangeEvent<HTMLInputElement>) => {
+        setSearch(event.target.value);
+        setIsOpen(true);
+      },
+      onFocus: () => setIsOpen(true),
+      placeholder: selectedOption ? selectedOption.label : 'None',
+      role: 'combobox',
+      type: 'text',
+      value: search,
+    }),
+    props.model.target
+      ? React.createElement(
+          'button',
+          {
+            className: 'btn btn-link btn-sm target-select-clear',
+            onClick: () => onChange(''),
+            type: 'button',
+          },
+          'None',
+        )
+      : null,
+    isOpen
+      ? React.createElement(
+          'div',
+          { className: 'target-select-options', role: 'listbox' },
+          filteredOptions.map((option) =>
+            React.createElement(
+              'button',
+              {
+                className: 'target-select-option',
+                key: option.val,
+                onClick: () => onChange(option.val),
+                type: 'button',
+              },
+              React.createElement('strong', null, option.label),
+              React.createElement('div', { className: 'target-select-description' }, option.description),
+            ),
+          ),
+        )
+      : null,
+  );
+}

package/src/pipeline/config/actions/delete/DeletePipelineModal.tsx

@@ -1,5 +1,5 @@
+import { useRouter } from '@uirouter/react';
 import { get, isEmpty, set } from 'lodash';
-import { $log } from 'ngimport';
 import React from 'react';
 import { Modal } from 'react-bootstrap';
 
@@ -7,9 +7,8 @@ import type { Application } from '../../../../application';
 import type { IPipeline } from '../../../../domain';
 import { ModalClose } from '../../../../modal';
 import type { IModalComponentProps } from '../../../../presentation';
-import { ReactInjector } from '../../../../reactShims';
-
 import { PipelineConfigService } from '../../services/PipelineConfigService';
+import { diagnosticLogger } from '../../../../utils/diagnosticLogger';
 
 export interface IDeletePipelineModalProps extends IModalComponentProps {
   application: Application;
@@ -17,6 +16,7 @@ export interface IDeletePipelineModalProps extends IModalComponentProps {
 }
 
 export function DeletePipelineModal(props: IDeletePipelineModalProps) {
+  const { stateService } = useRouter();
   const [errorMessage, setErrorMessage] = React.useState<string>(null);
   const [deleteError, setDeleteError] = React.useState<boolean>(false);
   const [deleting, setDeleting] = React.useState<boolean>(false);
@@ -43,11 +43,11 @@ export function DeletePipelineModal(props: IDeletePipelineModalProps) {
         if (!isEmpty(idsToUpdatedIndices)) {
           PipelineConfigService.reorderPipelines(application.name, idsToUpdatedIndices, isPipelineStrategy);
         }
-        ReactInjector.$state.go('^.executions', null, { location: 'replace' });
+        stateService.go('^.executions', null, { location: 'replace' });
         closeModal();
       },
       (response) => {
-        $log.warn(response);
+        diagnosticLogger.warn(response);
         setDeleting(false);
         setDeleteError(true);
         setErrorMessage(get(response, 'data.message', 'No message provided'));

package/src/pipeline/config/copyStage/CopyStageModal.tsx

@@ -37,7 +37,7 @@ export function CopyStageModal(props: ICopyStageModalProps) {
 
   const error = fetchApplications.status === 'REJECTED' || fetchStages.status === 'REJECTED';
 
-  function getStagesForApplication(applicationName: string): PromiseLike<ICopyStageCardProps[]> {
+  function getStagesForApplication(applicationName: string): Promise<ICopyStageCardProps[]> {
     const configType = forStrategyConfig ? 'strategyConfigs' : 'pipelineConfigs';
 
     return REST('/applications')

package/src/pipeline/config/graph/PipelineGraph.spec.tsx

@@ -0,0 +1,98 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import type { IPipeline } from '../../../domain';
+import { PipelineGraph } from './PipelineGraph';
+
+describe('PipelineGraph', () => {
+  let container: HTMLDivElement;
+  let originalResizeObserver: typeof ResizeObserver;
+  let originalRequestAnimationFrame: typeof requestAnimationFrame;
+  let requestAnimationFrameSpy: jasmine.Spy;
+  let resizeCallback: ResizeObserverCallback;
+
+  const pipeline: IPipeline = {
+    application: 'app',
+    id: 'pipeline-id',
+    name: 'Pipeline',
+    stages: [{ refId: '1', name: 'Bake', type: 'bake', requisiteStageRefIds: [] } as any],
+    triggers: [],
+    parameterConfig: [],
+    notifications: [],
+    limitConcurrent: true,
+    keepWaitingPipelines: false,
+  };
+
+  beforeEach(() => {
+    container = document.createElement('div');
+    container.style.width = '0px';
+    document.body.appendChild(container);
+    originalResizeObserver = window.ResizeObserver;
+    originalRequestAnimationFrame = window.requestAnimationFrame;
+    requestAnimationFrameSpy = spyOn(window, 'requestAnimationFrame').and.returnValue(1);
+    (window as any).ResizeObserver = class {
+      public observe = jasmine.createSpy('observe');
+      public disconnect = jasmine.createSpy('disconnect');
+
+      constructor(callback: ResizeObserverCallback) {
+        resizeCallback = callback;
+      }
+    };
+  });
+
+  afterEach(() => {
+    window.ResizeObserver = originalResizeObserver;
+    window.requestAnimationFrame = originalRequestAnimationFrame;
+    container.remove();
+    resizeCallback = undefined;
+  });
+
+  it('recalculates graph layout when the element receives width after mounting', () => {
+    const wrapper = mount(
+      <PipelineGraph
+        pipeline={pipeline}
+        viewState={{ section: 'triggers' } as any}
+        onNodeClick={jasmine.createSpy()}
+      />,
+      { attachTo: container },
+    );
+    const graph = wrapper.find(PipelineGraph).instance() as PipelineGraph;
+
+    expect(resizeCallback).toBeDefined();
+    expect(graph.state.graphWidth).not.toBe('100%');
+
+    container.style.width = '600px';
+    resizeCallback(
+      [{ target: wrapper.find('div.pipeline-graph').getDOMNode(), contentRect: { width: 600 } } as any],
+      {} as any,
+    );
+    wrapper.update();
+
+    expect(graph.state.graphWidth).toBe('100%');
+
+    wrapper.unmount();
+  });
+
+  it('retries layout when mounted before the element has width', () => {
+    const wrapper = mount(
+      <PipelineGraph
+        pipeline={pipeline}
+        viewState={{ section: 'triggers' } as any}
+        onNodeClick={jasmine.createSpy()}
+      />,
+      { attachTo: container },
+    );
+    const graph = wrapper.find(PipelineGraph).instance() as PipelineGraph;
+
+    expect(graph.state.graphWidth).not.toBe('100%');
+    expect(requestAnimationFrameSpy).toHaveBeenCalled();
+
+    container.style.width = '600px';
+    requestAnimationFrameSpy.calls.mostRecent().args[0](0);
+    wrapper.update();
+
+    expect(graph.state.graphWidth).toBe('100%');
+
+    wrapper.unmount();
+  });
+});

package/src/pipeline/config/graph/PipelineGraph.tsx

@@ -57,8 +57,13 @@ export class PipelineGraph extends React.Component<IPipelineGraphProps, IPipelin
     loading: false,
   };
   private element: JQuery;
+  private graphResizeObserver: ResizeObserver;
   private graphStatusHash: string;
   private graphVerticalPadding = 11;
+  private lastElementWidth = 0;
+  private layoutRetryFrame: number | null = null;
+  private layoutRetryCount = 0;
+  private maxLayoutRetries = 10;
   private minExecutionGraphHeight = 40;
   private minLabelWidth = 100;
   private pipelineValidations: IPipelineValidationResults = { pipeline: [], stages: [] };
@@ -95,6 +100,35 @@ export class PipelineGraph extends React.Component<IPipelineGraphProps, IPipelin
     this.updateGraph(this.props);
   }
 
+  private scheduleLayoutRetry(): void {
+    if (this.layoutRetryFrame !== null || this.layoutRetryCount >= this.maxLayoutRetries) {
+      return;
+    }
+
+    this.layoutRetryCount++;
+    this.layoutRetryFrame = window.requestAnimationFrame(() => {
+      this.layoutRetryFrame = null;
+      this.updateGraph(this.props);
+    });
+  }
+
+  private handleElementResize = (entries?: ResizeObserverEntry[]): void => {
+    if (!this.element?.length) {
+      return;
+    }
+    const width = entries?.[0]?.contentRect?.width || this.element.width() || 0;
+    if (!width) {
+      this.scheduleLayoutRetry();
+      return;
+    }
+    if (width === this.lastElementWidth) {
+      return;
+    }
+    this.lastElementWidth = width;
+    this.layoutRetryCount = 0;
+    this.updateGraph(this.props);
+  };
+
   private handleWheel = (e: React.WheelEvent<HTMLDivElement>) => {
     // track and save the graph scroll position for executions so it doesn't get reset to
     // zero every second due to repaint.
@@ -289,7 +323,14 @@ export class PipelineGraph extends React.Component<IPipelineGraphProps, IPipelin
    */
   private applyPhaseWidth(props: IPipelineGraphProps, newState: IPipelineGraphState): void {
     const phaseOffset = 2 * newState.nodeRadius + newState.labelOffsetX;
-    newState.maxLabelWidth = this.element.width() - 2 * newState.nodeRadius;
+    const elementWidth = this.element.width() || 0;
+    this.lastElementWidth = elementWidth;
+    if (!elementWidth) {
+      this.scheduleLayoutRetry();
+    } else {
+      this.layoutRetryCount = 0;
+    }
+    newState.maxLabelWidth = elementWidth - 2 * newState.nodeRadius;
 
     if (newState.phaseCount) {
       newState.maxLabelWidth = newState.maxLabelWidth / (newState.phaseCount + 1) - phaseOffset;
@@ -441,6 +482,7 @@ export class PipelineGraph extends React.Component<IPipelineGraphProps, IPipelin
 
   public componentDidMount() {
     window.addEventListener('resize', this.windowResize);
+    this.observeElementResize();
     this.validationSubscription = PipelineConfigValidator.subscribe((validations) => {
       this.pipelineValidations = validations;
       this.updateGraph(this.props);
@@ -454,6 +496,14 @@ export class PipelineGraph extends React.Component<IPipelineGraphProps, IPipelin
     }
   };
 
+  private observeElementResize(): void {
+    if (!window.ResizeObserver || !this.element?.length || this.graphResizeObserver) {
+      return;
+    }
+    this.graphResizeObserver = new ResizeObserver(this.handleElementResize);
+    this.graphResizeObserver.observe(this.element[0]);
+  }
+
   @Debounce(300)
   private validatePipeline(pipeline: IPipeline): void {
     PipelineConfigValidator.validatePipeline(pipeline).catch(() => {});
@@ -506,6 +556,10 @@ export class PipelineGraph extends React.Component<IPipelineGraphProps, IPipelin
 
   public componentWillUnmount() {
     this.validationSubscription.unsubscribe();
+    if (this.layoutRetryFrame !== null) {
+      window.cancelAnimationFrame(this.layoutRetryFrame);
+    }
+    this.graphResizeObserver?.disconnect();
     window.removeEventListener('resize', this.windowResize);
   }
 

package/src/pipeline/config/graph/pipelineGraph.less

@@ -14,7 +14,6 @@
   }
 }
 
-pipeline-graph,
 .pipeline-graph {
   display: block;
   overflow-x: auto;

package/src/pipeline/config/graph/pipelineGraph.service.ts

@@ -14,7 +14,7 @@ export interface IPipelineGraphLink {
   child: IPipelineGraphNode;
   isHighlighted?: boolean;
   line: string;
-  linkClass?: string; // Added after the fact in PipelineGraphDirective
+  linkClass?: string;
   parent: IPipelineGraphNode;
 }
 
@@ -22,7 +22,7 @@ export interface IPipelineGraphNode {
   childLinks: IPipelineGraphLink[];
   children: IPipelineGraphNode[];
   color?: string;
-  height?: number; // Added after the fact in PipelineGraphDirective
+  height?: number;
   id: string | number;
   index?: number;
   leaf?: boolean;
@@ -33,9 +33,9 @@ export interface IPipelineGraphNode {
   placeholder?: boolean;
   root?: boolean;
   graphRowOverride?: number;
-  row?: number; // Added after the fact in PipelineGraphDirective
-  x?: number; // Added after the fact in PipelineGraphDirective
-  y?: number; // Added after the fact in PipelineGraphDirective
+  row?: number;
+  x?: number;
+  y?: number;
 
   // PipelineGraphComponent conflates the two node types, so adding as optional here
   // Config node parameters
@@ -43,7 +43,7 @@ export interface IPipelineGraphNode {
   hasWarnings?: boolean;
   isActive: boolean;
   isHighlighted: boolean;
-  lastPhase?: number; // Added after the fact in PipelineGraphDirective
+  lastPhase?: number;
   phase?: number;
   section?: string;
   warnings?: { messages: string[] };

package/src/pipeline/config/pipelineConfig.less

@@ -1,10 +1,5 @@
 @import (reference) '../../presentation/less/imports/commonImports.less';
 
-.stage-choice {
-  .ui-select-highlight {
-    text-decoration: underline;
-  }
-}
 .stage-choice-heading {
   display: flex;
   strong {
@@ -16,7 +11,18 @@
   }
 }
 
-pipeline-configurer {
+.pipeline-stage-dependency-select.Select--multi {
+  width: 100%;
+
+  .Select-control,
+  .Select-multi-value-wrapper,
+  .Select-input {
+    height: auto;
+    min-height: 30px;
+  }
+}
+
+.pipeline-configurer {
   margin-top: 15px;
   display: block;
   background-color: transparent;
@@ -54,7 +60,7 @@ pipeline-configurer {
     }
   }
 
-  pipeline-config-view {
+  .pipeline-config-view {
     display: block;
     margin-left: -15px;
     margin-right: -15px;
@@ -79,12 +85,6 @@ pipeline-configurer {
       margin: 0;
       font-weight: 600;
     }
-    .select2-container-multi {
-      box-shadow: none;
-      .select2-choices {
-        background-color: transparent;
-      }
-    }
   }
 
   .pipeline-stage-config-heading p {
@@ -119,7 +119,6 @@ triggers,
     margin-bottom: 10px;
   }
   trigger,
-  expected-artifact,
   .trigger-config {
     display: block;
     padding: 10px 20px;
@@ -137,6 +136,14 @@ triggers,
   margin-bottom: 15px;
 }
 
+.content-url-preview {
+  display: inline-block;
+  padding-top: 7px;
+  font-family: monospace;
+  word-break: break-all;
+  color: var(--color-titanium);
+}
+
 .config-section {
   padding: 0;
   display: inline-block;
@@ -171,11 +178,6 @@ triggers,
   &.no-border {
     border-width: 0;
   }
-  .select2-result-label {
-    h5 {
-      margin: 5px 0 0 0;
-    }
-  }
 }
 
 .pipeline-graph-container {

package/src/pipeline/config/pipelineConfig.module.js

@@ -1,19 +1,6 @@
 'use strict';
 
-import { module } from 'angular';
-
-import { CREATE_PIPELINE_COMPONENT } from './createPipeline.component';
-import { PIPELINE_GRAPH_COMPONENT } from './graph/pipeline.graph.component';
-import { CORE_PIPELINE_CONFIG_HEALTH_STAGEPLATFORMHEALTHOVERRIDE_DIRECTIVE } from './health/stagePlatformHealthOverride.directive';
-import { CORE_PIPELINE_CONFIG_PARAMETERS_PIPELINE_MODULE } from './parameters/pipeline.module';
-import { CORE_PIPELINE_CONFIG_PIPELINECONFIG_CONTROLLER } from './pipelineConfig.controller';
-import { CORE_PIPELINE_CONFIG_PIPELINECONFIGVIEW } from './pipelineConfigView';
-import { CORE_PIPELINE_CONFIG_PIPELINECONFIGURER } from './pipelineConfigurer';
-import { CORE_PIPELINE_CONFIG_STAGES_BASEPROVIDERSTAGE_BASEPROVIDERSTAGE } from './stages/baseProviderStage/baseProviderStage';
-import { CORE_PIPELINE_CONFIG_STAGES_STAGE_MODULE } from './stages/stage.module';
-import { TARGET_SELECT_COMPONENT } from './targetSelect.component';
 import './triggers';
-import { TRIGGERS } from './triggers/triggers.module';
 import './validation/anyFieldRequired.validator';
 import './validation/imageProviderBeforeType.validator';
 import './validation/repositoryInformationProvided.validator';
@@ -25,19 +12,3 @@ import './validation/targetImpedance.validator';
 import './validation/upstreamVersionProvided.validator';
 
 import './pipelineConfig.less';
-
-export const CORE_PIPELINE_CONFIG_PIPELINECONFIG_MODULE = 'spinnaker.core.pipeline.config';
-export const name = CORE_PIPELINE_CONFIG_PIPELINECONFIG_MODULE; // for backwards compatibility
-module(CORE_PIPELINE_CONFIG_PIPELINECONFIG_MODULE, [
-  CREATE_PIPELINE_COMPONENT,
-  PIPELINE_GRAPH_COMPONENT,
-  CORE_PIPELINE_CONFIG_STAGES_STAGE_MODULE,
-  CORE_PIPELINE_CONFIG_STAGES_BASEPROVIDERSTAGE_BASEPROVIDERSTAGE,
-  TRIGGERS,
-  CORE_PIPELINE_CONFIG_PARAMETERS_PIPELINE_MODULE,
-  CORE_PIPELINE_CONFIG_PIPELINECONFIG_CONTROLLER,
-  CORE_PIPELINE_CONFIG_PIPELINECONFIGVIEW,
-  CORE_PIPELINE_CONFIG_PIPELINECONFIGURER,
-  TARGET_SELECT_COMPONENT,
-  CORE_PIPELINE_CONFIG_HEALTH_STAGEPLATFORMHEALTHOVERRIDE_DIRECTIVE,
-]);

package/src/pipeline/config/preconditions/EditPreconditionModal.spec.tsx

@@ -0,0 +1,78 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { EditPreconditionModal } from './EditPreconditionModal';
+import { PreconditionSelector } from './PreconditionSelector';
+
+describe('<EditPreconditionModal />', () => {
+  const createProps = (overrides = {}) => ({
+    application: { getDataSource: () => ({ data: [] }) } as any,
+    closeModal: jasmine.createSpy('closeModal'),
+    dismissModal: jasmine.createSpy('dismissModal'),
+    precondition: {
+      type: 'expression',
+      failPipeline: true,
+      context: { expression: '${foo}' },
+    },
+    strategy: false,
+    upstreamStages: [{ name: 'Bake' }] as any[],
+    ...overrides,
+  });
+
+  it('edits a cloned precondition and submits the edited copy', () => {
+    const props = createProps();
+    const component = mount(<EditPreconditionModal {...props} />);
+    const updatedPrecondition = { type: 'expression', failPipeline: false, context: { expression: '${bar}' } };
+
+    const selector = component.find(PreconditionSelector);
+    expect(selector.prop('precondition')).not.toBe(props.precondition);
+
+    selector.prop('onChange')(updatedPrecondition);
+    const submitButton = component.find('button[data-purpose="submit"]');
+
+    expect(submitButton.prop('disabled')).toBe(false);
+    submitButton.simulate('click');
+
+    expect(props.precondition.context.expression).toBe('${foo}');
+    expect(props.closeModal).toHaveBeenCalledWith(updatedPrecondition);
+  });
+
+  it('disables submit when an expression precondition is missing the expression', () => {
+    const props = createProps({
+      precondition: {
+        type: 'expression',
+        failPipeline: true,
+        context: {},
+      },
+    });
+    const component = mount(<EditPreconditionModal {...props} />);
+
+    expect(component.find('button[data-purpose="submit"]').prop('disabled')).toBe(true);
+  });
+
+  it('disables submit when a cluster size precondition is missing required fields', () => {
+    const props = createProps({
+      precondition: {
+        type: 'clusterSize',
+        failPipeline: true,
+        context: { comparison: '==' },
+      },
+    });
+    const component = mount(<EditPreconditionModal {...props} />);
+
+    expect(component.find('button[data-purpose="submit"]').prop('disabled')).toBe(true);
+  });
+
+  it('disables submit when a stage status precondition is missing stage status fields', () => {
+    const props = createProps({
+      precondition: {
+        type: 'stageStatus',
+        failPipeline: true,
+        context: { stageName: 'Bake' },
+      },
+    });
+    const component = mount(<EditPreconditionModal {...props} />);
+
+    expect(component.find('button[data-purpose="submit"]').prop('disabled')).toBe(true);
+  });
+});