@spinnaker/core 2026.2.3 → 2026.3.0

package/src/cluster/onDemand/OnDemandClusterPicker.tsx

@@ -0,0 +1,114 @@
+import React, { useEffect, useState } from 'react';
+
+import { AccountTag } from '../../account';
+import type { Application } from '../../application';
+import type { ApplicationDataSource } from '../../application/service/applicationDataSource';
+import type { IClusterSummary } from '../../domain';
+import { ReactSelectInput } from '../../presentation';
+import { ClusterState } from '../../state';
+
+import './onDemandClusterPicker.component.less';
+
+export interface IOnDemandClusterOption {
+  account: string;
+  label: string;
+  name: string;
+  value: string;
+}
+
+export interface IOnDemandClusterPickerProps {
+  application: Application;
+}
+
+type OnDemandServerGroupsDataSource = ApplicationDataSource<unknown[]> & {
+  clusters?: IClusterSummary[];
+  fetchOnDemand?: boolean;
+};
+
+export function makeClusterFilterKey(cluster: Pick<IClusterSummary, 'account' | 'name'>): string {
+  return `${cluster.account}:${cluster.name}`;
+}
+
+export function getAvailableClusters(
+  clusters: IClusterSummary[] = [],
+  selectedClusters: Record<string, unknown> = {},
+): IOnDemandClusterOption[] {
+  return (clusters || [])
+    .filter((cluster) => !selectedClusters?.[makeClusterFilterKey(cluster)])
+    .map((cluster) => ({
+      account: cluster.account,
+      label: cluster.name,
+      name: cluster.name,
+      value: makeClusterFilterKey(cluster),
+    }));
+}
+
+export function filterClusterOptions(
+  options: IOnDemandClusterOption[] = [],
+  filter = '',
+  limit = 50,
+): IOnDemandClusterOption[] {
+  const normalizedFilter = filter.toLocaleLowerCase();
+  return (options || [])
+    .filter(({ account, name }) => `${account} ${name}`.toLocaleLowerCase().includes(normalizedFilter))
+    .slice(0, limit);
+}
+
+export function OnDemandClusterPicker({ application }: IOnDemandClusterPickerProps): JSX.Element {
+  const serverGroups = application.getDataSource('serverGroups') as OnDemandServerGroupsDataSource;
+  const readClusters = () => {
+    const clusters = Array.isArray(serverGroups.clusters) ? serverGroups.clusters : [];
+    const selectedClusters = ClusterState.filterModel.asFilterModel.sortFilter.clusters || {};
+    return {
+      availableClusters: getAvailableClusters(clusters, selectedClusters),
+      totalClusterCount: clusters.length,
+    };
+  };
+  const [clusterState, setClusterState] = useState(readClusters);
+
+  useEffect(() => {
+    const updateClusters = () => setClusterState(readClusters());
+    updateClusters();
+    return serverGroups.onRefresh(updateClusters);
+  }, [application]);
+
+  const selectCluster = (event: React.ChangeEvent<HTMLInputElement>): void => {
+    const clusterKey = event?.target?.value;
+    if (!clusterKey) {
+      return;
+    }
+
+    const sortFilter = ClusterState.filterModel.asFilterModel.sortFilter;
+    sortFilter.clusters = sortFilter.clusters || {};
+    sortFilter.clusters[clusterKey] = true;
+    ClusterState.filterModel.asFilterModel.applyParamsToUrl();
+    setClusterState(readClusters());
+    serverGroups.refresh(true);
+  };
+
+  const renderOption = (option: IOnDemandClusterOption): JSX.Element => (
+    <span>
+      <AccountTag account={option.account} /> <span>{option.name}</span>
+    </span>
+  );
+
+  return (
+    <div className="on-demand-cluster-picker">
+      <h4>{clusterState.totalClusterCount} clusters found in this application</h4>
+      <p>
+        <strong>Not all clusters are shown.</strong> Select or enter a cluster name below to view:
+      </p>
+      <ReactSelectInput
+        mode="PLAIN"
+        name="cluster"
+        value={null}
+        options={clusterState.availableClusters}
+        filterOptions={(options, filter) => filterClusterOptions(options as IOnDemandClusterOption[], filter)}
+        optionRenderer={renderOption}
+        valueRenderer={renderOption}
+        onChange={selectCluster}
+        placeholder="Enter cluster name here"
+      />
+    </div>
+  );
+}

package/src/cluster/onDemand/onDemandClusterPicker.component.less

@@ -1,8 +1,13 @@
-on-demand-cluster-picker {
+.on-demand-cluster-picker {
   display: block;
   margin-bottom: 20px;
-  .dropdown-menu {
+
+  .Select-menu,
+  .Select-menu-outer {
     max-height: 50vh;
+  }
+
+  .Select-menu {
     overflow-y: auto;
   }
 }

package/src/cluster/rollups.less

@@ -245,14 +245,6 @@ table.instances {
   }
 }
 
-running-tasks-tag {
-  margin-right: 10px;
-
-  .icon-spinner {
-    color: var(--color-accent);
-  }
-}
-
 .popover.menu-running-tasks {
   border: 1px solid var(--color-dovegray);
   text-transform: none;

package/src/config/VersionChecker.spec.tsx

@@ -0,0 +1,39 @@
+import { VersionChecker } from './VersionChecker';
+import type { IScheduler } from '../scheduler/SchedulerFactory';
+import { SchedulerFactory } from '../scheduler/SchedulerFactory';
+
+describe('VersionChecker', () => {
+  beforeEach(() => VersionChecker.resetForTests());
+  afterEach(() => VersionChecker.resetForTests());
+
+  it('creates and subscribes one scheduler when initialized repeatedly', () => {
+    const scheduler: IScheduler = {
+      scheduleImmediate: jasmine.createSpy('scheduleImmediate'),
+      subscribe: jasmine.createSpy('subscribe'),
+      unsubscribe: jasmine.createSpy('unsubscribe'),
+    };
+    const createScheduler = spyOn(SchedulerFactory, 'createScheduler').and.returnValue(scheduler);
+
+    VersionChecker.initialize();
+    VersionChecker.initialize();
+
+    expect(createScheduler).toHaveBeenCalledTimes(1);
+    expect(scheduler.subscribe).toHaveBeenCalledTimes(1);
+  });
+
+  it('unsubscribes the active scheduler and permits fresh initialization after reset', () => {
+    const scheduler: IScheduler = {
+      scheduleImmediate: jasmine.createSpy('scheduleImmediate'),
+      subscribe: jasmine.createSpy('subscribe'),
+      unsubscribe: jasmine.createSpy('unsubscribe'),
+    };
+    const createScheduler = spyOn(SchedulerFactory, 'createScheduler').and.returnValue(scheduler);
+
+    VersionChecker.initialize();
+    VersionChecker.resetForTests();
+    VersionChecker.initialize();
+
+    expect(scheduler.unsubscribe).toHaveBeenCalledTimes(1);
+    expect(createScheduler).toHaveBeenCalledTimes(2);
+  });
+});

package/src/config/VersionChecker.tsx

@@ -1,10 +1,10 @@
-import { $http, $log } from 'ngimport';
 import React from 'react';
 // @ts-ignore
 import version from 'root/version.json';
 
 import type { IScheduler } from '../scheduler/SchedulerFactory';
 import { SchedulerFactory } from '../scheduler/SchedulerFactory';
+import { diagnosticLogger } from '../utils/diagnosticLogger';
 import { timestamp } from '../utils/timeFormatters';
 import { NotifierService } from '../widgets/notifier/notifier.service';
 
@@ -19,16 +19,28 @@ export class VersionChecker {
   private static scheduler: IScheduler;
 
   public static initialize(): void {
-    $log.debug('Deck version', this.currentVersion.version, 'created', timestamp(this.currentVersion.created));
+    if (this.scheduler) {
+      return;
+    }
+    this.logDebug('Deck version', this.currentVersion.version, 'created', timestamp(this.currentVersion.created));
     this.scheduler = SchedulerFactory.createScheduler();
     this.scheduler.subscribe(() => this.checkVersion());
   }
 
+  public static resetForTests(): void {
+    this.scheduler?.unsubscribe();
+    this.scheduler = null;
+    this.newVersionSeenCount = 0;
+  }
+
   private static checkVersion(): void {
     const url = `/version.json?_=${Date.now()}`;
-    $http
-      .get(url)
-      .then((resp) => this.versionRetrieved(resp))
+    const request: Promise<any> = fetch(url, { credentials: 'include' }).then((response) =>
+      response.json().then((data) => ({ data })),
+    );
+
+    Promise.resolve(request)
+      .then((resp: any) => this.versionRetrieved(resp))
       .catch(() => {});
   }
 
@@ -39,7 +51,7 @@ export class VersionChecker {
     } else {
       this.newVersionSeenCount++;
       if (this.newVersionSeenCount > 5) {
-        $log.debug('New Deck version:', data.version, 'created', timestamp(data.created));
+        this.logDebug('New Deck version:', data.version, 'created', timestamp(data.created));
         NotifierService.publish({
           key: 'newVersion',
           action: 'create',
@@ -56,4 +68,8 @@ export class VersionChecker {
       }
     }
   }
+
+  private static logDebug(...args: any[]): void {
+    diagnosticLogger.debug(...args);
+  }
 }

package/src/config/settings.ts

@@ -129,6 +129,7 @@ export interface ISpinnakerSettings {
   };
   maxFetchHistoryOnEvaluateVariables?: number;
   maxPipelineAgeDays: number;
+  maxPipelineTriggerExecutionOptions?: number;
   newApplicationDefaults: INewApplicationDefaults;
   notifications: INotificationSettings;
   onDemandClusterThreshold: number;
@@ -155,6 +156,7 @@ export interface ISpinnakerSettings {
   useClassicFirewallLabels: boolean;
   kubernetesAdHocInfraWritesEnabled: boolean;
   changelogUrl: string;
+  consoleLogRefreshIntervalMs?: number;
   cdevents?: {
     validUrlPattern: string;
     validCDEvent: string;
@@ -177,6 +179,8 @@ SETTINGS.managedDelivery = SETTINGS.managedDelivery || {
   manifestBasePath: '.spinnaker',
 };
 SETTINGS.maxFetchHistoryOnEvaluateVariables = SETTINGS.maxFetchHistoryOnEvaluateVariables ?? 100;
+SETTINGS.consoleLogRefreshIntervalMs = SETTINGS.consoleLogRefreshIntervalMs ?? 30000;
+SETTINGS.maxPipelineTriggerExecutionOptions = SETTINGS.maxPipelineTriggerExecutionOptions ?? 20;
 
 // A helper to make resetting settings to steady state after running tests easier
 const originalSettings: ISpinnakerSettings = cloneDeep(SETTINGS);

package/src/confirmationModal/ConfirmModal.spec.tsx

@@ -0,0 +1,211 @@
+import { UIRouterContext, UIRouterReact } from '@uirouter/react';
+import { mount } from 'enzyme';
+import React from 'react';
+import { act } from 'react-dom/test-utils';
+import { filter, take } from 'rxjs/operators';
+
+import { ConfirmModal } from './ConfirmModal';
+import { TaskMonitor, TaskReader } from '../task';
+import type { ITask } from '../domain';
+
+describe('ConfirmModal', () => {
+  it('requires a reason and uses the configured placeholder', () => {
+    const submitMethod = jasmine.createSpy('submitMethod').and.returnValue(Promise.resolve());
+    const closeModal = jasmine.createSpy('closeModal');
+    const dismissModal = jasmine.createSpy('dismissModal');
+    const taskMonitor = new TaskMonitor({
+      title: 'Page application owner',
+      onDismiss: () => undefined,
+    });
+    const wrapper = mount(
+      <ConfirmModal
+        header="Page payments Owner"
+        buttonText="Page Owner"
+        cancelButtonText="Cancel"
+        askForReason={true}
+        reasonRequired={true}
+        reasonPlaceholder="Why is the owner being paged?"
+        submitMethod={submitMethod}
+        closeModal={closeModal}
+        dismissModal={dismissModal}
+        taskMonitor={taskMonitor}
+      />,
+    );
+
+    expect(wrapper.find('button.btn-primary').prop('disabled')).toBe(true);
+    wrapper.find('textarea').simulate('change', { target: { value: '   ' } });
+    wrapper.update();
+    expect(wrapper.find('button.btn-primary').prop('disabled')).toBe(true);
+    wrapper.find('textarea').simulate('change', { target: { value: 'Production outage' } });
+    wrapper.update();
+    expect(wrapper.find('button.btn-primary').prop('disabled')).toBe(false);
+    expect(wrapper.find('textarea').prop('placeholder')).toBe('Why is the owner being paged?');
+
+    wrapper.unmount();
+  });
+
+  it('resets submitting after a task rejection when retry has no original callback', async () => {
+    let rejectSubmission: (reason: unknown) => void;
+    const submission = new Promise((_resolve, reject) => {
+      rejectSubmission = reject;
+    });
+    const submitMethod = jasmine.createSpy('submitMethod').and.returnValue(submission);
+    const taskMonitor = new TaskMonitor({ title: 'Page application owner' });
+    const router = new UIRouterReact();
+    const wrapper = mount(
+      <UIRouterContext.Provider value={router}>
+        <ConfirmModal
+          header="Page payments Owner"
+          buttonText="Page Owner"
+          cancelButtonText="Cancel"
+          submitMethod={submitMethod}
+          closeModal={jasmine.createSpy('closeModal')}
+          dismissModal={jasmine.createSpy('dismissModal')}
+          taskMonitor={taskMonitor}
+        />
+      </UIRouterContext.Provider>,
+    );
+
+    expect(taskMonitor.hasDismissHandler()).toBe(false);
+    act(() => {
+      wrapper.find('button.btn-primary').last().simulate('click');
+    });
+    wrapper.update();
+
+    expect(wrapper.find('button.btn-primary .load.nano').exists()).toBe(true);
+    const errorPublished = taskMonitor.statusUpdatedStream
+      .pipe(
+        filter(() => taskMonitor.error),
+        take(1),
+      )
+      .toPromise();
+    await act(async () => {
+      rejectSubmission({ failureMessage: 'Page request failed' });
+      await errorPublished;
+    });
+    wrapper.update();
+
+    expect(taskMonitor.error).toBe(true);
+    expect(wrapper.find('.overlay-modal-error').exists()).toBe(true);
+
+    act(() => {
+      wrapper
+        .find('button')
+        .filterWhere((button) => button.text() === 'Go back and try to fix this')
+        .simulate('click');
+    });
+    wrapper.update();
+
+    expect(taskMonitor.error).toBeNull();
+    expect(wrapper.find('.overlay-modal-error').exists()).toBe(false);
+    expect(wrapper.find('button.btn-primary').last().prop('disabled')).toBe(false);
+
+    wrapper.unmount();
+    router.dispose();
+  });
+
+  it('installs a local close override when the task monitor has no dismiss handler', () => {
+    const dismissModal = jasmine.createSpy('dismissModal');
+    const stopPropagation = jasmine.createSpy('stopPropagation');
+    const taskMonitor = new TaskMonitor({ title: 'Page application owner' });
+    const originalCloseModal = taskMonitor.closeModal;
+    const wrapper = mount(
+      <ConfirmModal
+        header="Page payments Owner"
+        buttonText="Page Owner"
+        cancelButtonText="Cancel"
+        closeModal={jasmine.createSpy('closeModal')}
+        dismissModal={dismissModal}
+        taskMonitor={taskMonitor}
+      />,
+    );
+
+    expect(taskMonitor.closeModal).not.toBe(originalCloseModal);
+    taskMonitor.closeModal({ stopPropagation } as any);
+
+    expect(stopPropagation).toHaveBeenCalledTimes(1);
+    expect(dismissModal).toHaveBeenCalledTimes(1);
+
+    wrapper.unmount();
+    expect(taskMonitor.closeModal).toBe(originalCloseModal);
+  });
+
+  it('closes the task monitor before dismissing and dismisses only once when dismissal throws', async () => {
+    jasmine.clock().install();
+    const poll = jasmine.createSpy('poll');
+    const activeTask = { poller: setTimeout(poll, 25) } as ITask;
+    const lateTask = { id: 'late-task', status: 'RUNNING' } as ITask;
+    let resolveSubmission: (task: ITask) => void;
+    const submission = new Promise<ITask>((resolve) => (resolveSubmission = resolve));
+    const waitUntilTaskCompletes = spyOn(TaskReader, 'waitUntilTaskCompletes');
+    const dismissalError = new Error('dismiss failed');
+    let pollingWasActiveAtDismiss: boolean;
+    const taskMonitor = new TaskMonitor({ title: 'Page application owner' });
+    const router = new UIRouterReact();
+    const dismissModal = jasmine.createSpy('dismissModal').and.callFake(() => {
+      pollingWasActiveAtDismiss = activeTask.poller !== undefined;
+      resolveSubmission(lateTask);
+      throw dismissalError;
+    });
+    const wrapper = mount(
+      <UIRouterContext.Provider value={router}>
+        <ConfirmModal
+          header="Page payments Owner"
+          buttonText="Page Owner"
+          cancelButtonText="Cancel"
+          closeModal={jasmine.createSpy('closeModal')}
+          dismissModal={dismissModal}
+          taskMonitor={taskMonitor}
+        />
+      </UIRouterContext.Provider>,
+    );
+
+    try {
+      taskMonitor.submit(() => submission);
+      taskMonitor.task = activeTask;
+
+      expect(() => taskMonitor.closeModal()).toThrow(dismissalError);
+      await Promise.resolve();
+      await Promise.resolve();
+
+      expect(pollingWasActiveAtDismiss).toBe(false);
+      expect(activeTask.poller).toBeUndefined();
+      jasmine.clock().tick(25);
+      expect(poll).not.toHaveBeenCalled();
+      expect(waitUntilTaskCompletes).not.toHaveBeenCalled();
+      expect(taskMonitor.task).toBe(activeTask);
+
+      expect(() => taskMonitor.closeModal()).not.toThrow();
+      expect(dismissModal).toHaveBeenCalledTimes(1);
+    } finally {
+      wrapper.unmount();
+      router.dispose();
+      jasmine.clock().uninstall();
+    }
+  });
+
+  it('keeps the task monitor close handler when it has a direct dismiss handler', () => {
+    const onDismiss = jasmine.createSpy('onDismiss');
+    const dismissModal = jasmine.createSpy('dismissModal');
+    const taskMonitor = new TaskMonitor({ title: 'Page application owner', onDismiss });
+    const originalCloseModal = taskMonitor.closeModal;
+    const wrapper = mount(
+      <ConfirmModal
+        header="Page payments Owner"
+        buttonText="Page Owner"
+        cancelButtonText="Cancel"
+        closeModal={jasmine.createSpy('closeModal')}
+        dismissModal={dismissModal}
+        taskMonitor={taskMonitor}
+      />,
+    );
+
+    expect(taskMonitor.closeModal).toBe(originalCloseModal);
+    taskMonitor.closeModal();
+
+    expect(onDismiss).toHaveBeenCalledTimes(1);
+    expect(dismissModal).not.toHaveBeenCalled();
+
+    wrapper.unmount();
+  });
+});

package/src/confirmationModal/ConfirmModal.tsx

@@ -6,7 +6,8 @@ import type { IConfirmationModalPassthroughProps } from './confirmationModal.ser
 import { ModalClose } from '../modal';
 import type { IModalComponentProps } from '../presentation';
 import { Markdown, useEscapeKeyPressed } from '../presentation';
-import { TaskMonitor, TaskMonitorWrapper, TaskReason, UserVerification } from '../task';
+import type { TaskMonitor } from '../task';
+import { TaskMonitorWrapper, TaskReason, UserVerification } from '../task';
 import { MultiTaskMonitor } from '../task/monitor/MultiTaskMonitor';
 import { Spinner } from '../widgets/spinners/Spinner';
 
@@ -30,21 +31,45 @@ export const ConfirmModal = (props: IConfirmModalProps) => {
   useEscapeKeyPressed(() => dismissModal());
 
   useEffect(() => {
-    if (taskMonitor && !taskMonitor.modalInstance) {
-      taskMonitor.modalInstance = TaskMonitor.modalInstanceEmulation(closeModal, dismissModal);
+    if (!taskMonitor) {
+      return undefined;
     }
-    if (taskMonitor?.onTaskRetry) {
-      const { onTaskRetry } = taskMonitor;
-      taskMonitor.onTaskRetry = () => {
-        setIsRetry(true);
-        setIsSubmitting(false);
-        onTaskRetry();
-      };
+
+    const originalOnTaskRetry = taskMonitor.onTaskRetry;
+    const handleTaskRetry = () => {
+      setIsRetry(true);
+      setIsSubmitting(false);
+      originalOnTaskRetry?.();
+    };
+    taskMonitor.onTaskRetry = handleTaskRetry;
+
+    const originalCloseModal = taskMonitor.closeModal;
+    let hasDismissed = false;
+    const handleTaskMonitorClose = (event?: React.MouseEvent<any>) => {
+      originalCloseModal(event);
+      if (hasDismissed) {
+        return;
+      }
+      hasDismissed = true;
+      dismissModal();
+    };
+    if (!taskMonitor.hasDismissHandler()) {
+      taskMonitor.closeModal = handleTaskMonitorClose;
     }
-  }, [taskMonitor]);
+
+    return () => {
+      if (taskMonitor.onTaskRetry === handleTaskRetry) {
+        taskMonitor.onTaskRetry = originalOnTaskRetry;
+      }
+      if (taskMonitor.closeModal === handleTaskMonitorClose) {
+        taskMonitor.closeModal = originalCloseModal;
+      }
+    };
+  }, [taskMonitor, dismissModal]);
 
   const requiresVerification = account || (verificationLabel && textToVerify);
-  const isDisabled = isSubmitting || !isValid;
+  const reasonIsValid = !props.reasonRequired || Boolean(reason?.trim());
+  const isDisabled = isSubmitting || !isValid || !reasonIsValid;
 
   const showError = (e: string) => {
     setError({ isError: true, message: e });
@@ -116,7 +141,7 @@ export const ConfirmModal = (props: IConfirmModalProps) => {
             </div>
           )}
           {isRetry && props.retryBody && <Markdown message={props.retryBody} />}
-          {showReasonInput && <TaskReason reason={reason} onChange={setReason} />}
+          {showReasonInput && <TaskReason reason={reason} placeholder={props.reasonPlaceholder} onChange={setReason} />}
         </Modal.Body>
       )}
       <Modal.Footer>

package/src/confirmationModal/confirmationModal.service.spec.ts

@@ -0,0 +1,105 @@
+import type { IConfirmModalProps } from './ConfirmModal';
+import { ConfirmationModalService } from './confirmationModal.service';
+import type { ITask } from '../domain';
+import { ReactModal } from '../presentation/ReactModal';
+import type { TaskMonitor } from '../task';
+import { TaskReader } from '../task/task.read.service';
+
+const createDeferred = <T>() => {
+  let resolve: (value: T | PromiseLike<T>) => void;
+  let reject: (reason?: unknown) => void;
+  const promise = new Promise<T>((promiseResolve, promiseReject) => {
+    resolve = promiseResolve;
+    reject = promiseReject;
+  });
+
+  return { promise, reject, resolve };
+};
+
+describe('ConfirmationModalService', () => {
+  it('resolves the direct modal result', async () => {
+    const modalPromise = Promise.resolve('confirmed');
+    spyOn(ReactModal, 'show').and.returnValue(modalPromise);
+
+    const confirmation = ConfirmationModalService.confirm({ header: 'Rollout restart' });
+
+    expect(confirmation).toBe(modalPromise);
+    expect(await confirmation).toBe('confirmed');
+    expect(ReactModal.show).toHaveBeenCalled();
+  });
+
+  it('cleans task polling when the native modal resolves and returns the same promise', async () => {
+    const modal = createDeferred<string>();
+    const show = spyOn(ReactModal, 'show').and.returnValue(modal.promise);
+
+    const confirmation = ConfirmationModalService.confirm({
+      header: 'Rollout restart',
+      taskMonitorConfig: { title: 'Restarting instances' },
+    });
+    const taskMonitor = (show.calls.mostRecent().args[1] as IConfirmModalProps).taskMonitor as TaskMonitor;
+    const onModalClose = spyOn(taskMonitor, 'onModalClose');
+
+    expect(confirmation).toBe(modal.promise);
+    modal.resolve('confirmed');
+
+    expect(await confirmation).toBe('confirmed');
+    expect(onModalClose).toHaveBeenCalledTimes(1);
+
+    modal.reject(new Error('late dismissal'));
+    await Promise.resolve();
+    expect(onModalClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('cleans task polling when the native modal rejects and preserves the rejection', async () => {
+    const modal = createDeferred<string>();
+    const show = spyOn(ReactModal, 'show').and.returnValue(modal.promise);
+    const dismissal = new Error('dismissed');
+
+    const confirmation = ConfirmationModalService.confirm({
+      header: 'Rollout restart',
+      taskMonitorConfig: { title: 'Restarting instances' },
+    });
+    const taskMonitor = (show.calls.mostRecent().args[1] as IConfirmModalProps).taskMonitor as TaskMonitor;
+    const onModalClose = spyOn(taskMonitor, 'onModalClose');
+    const rejection = confirmation.then(
+      () => Promise.reject(new Error('Expected confirmation to reject')),
+      (reason) => reason,
+    );
+
+    expect(confirmation).toBe(modal.promise);
+    modal.reject(dismissal);
+
+    expect(await rejection).toBe(dismissal);
+    expect(onModalClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not start polling when a pending submission resolves after native modal dismissal', async () => {
+    const modal = createDeferred<string>();
+    const submission = createDeferred<ITask>();
+    const show = spyOn(ReactModal, 'show').and.returnValue(modal.promise);
+    const waitUntilTaskCompletes = spyOn(TaskReader, 'waitUntilTaskCompletes').and.returnValue(
+      new Promise(() => undefined),
+    );
+
+    const confirmation = ConfirmationModalService.confirm({
+      header: 'Rollout restart',
+      taskMonitorConfig: { title: 'Restarting instances' },
+    });
+    const taskMonitor = (show.calls.mostRecent().args[1] as IConfirmModalProps).taskMonitor as TaskMonitor;
+    taskMonitor.submit(() => submission.promise);
+    const dismissal = confirmation.then(
+      () => Promise.reject(new Error('Expected confirmation to reject')),
+      (reason) => reason,
+    );
+
+    modal.reject('dismissed');
+    expect(await dismissal).toBe('dismissed');
+
+    submission.resolve({ id: 'late-task' } as ITask);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(waitUntilTaskCompletes).not.toHaveBeenCalled();
+    expect(taskMonitor.task).toBeNull();
+  });
+});