@spinnaker/ecs 2026.2.4 → 2026.3.1

package/src/serverGroup/details/resize/EcsResizeServerGroupModal.spec.tsx

@@ -0,0 +1,130 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import {
+  PlatformHealthOverride,
+  ReactModal,
+  SpinFormik,
+  TaskMonitorWrapper,
+  TaskReason,
+  UserVerification,
+} from '@spinnaker/core';
+
+import { EcsResizeServerGroupModal, validateEcsResizeValues } from './index';
+
+describe('EcsResizeServerGroupModal', () => {
+  const serverGroup = {
+    account: 'test-account',
+    capacity: { desired: 4, max: 8, min: 2 },
+    name: 'fnord-main-v004',
+    region: 'eu-west-1',
+  };
+
+  function application(attributes: any = {}) {
+    return {
+      attributes,
+      serverGroups: { refresh: jasmine.createSpy('refresh') },
+    } as any;
+  }
+
+  function props(app = application()) {
+    return {
+      application: app,
+      closeModal: jasmine.createSpy('closeModal'),
+      dismissModal: jasmine.createSpy('dismissModal'),
+      serverGroup: serverGroup as any,
+    };
+  }
+
+  it('validates non-negative min, max, and desired capacities in range', () => {
+    expect(validateEcsResizeValues({ capacity: { desired: 4, max: 8, min: -1 } })).toEqual({
+      capacity: { min: 'Min cannot be negative' },
+    });
+    expect(validateEcsResizeValues({ capacity: { desired: 4, max: 1, min: 2 } })).toEqual({
+      capacity: { max: 'Max cannot be smaller than Min', min: 'Min cannot be larger than Max' },
+    });
+    expect(validateEcsResizeValues({ capacity: { desired: 1, max: 8, min: 2 } })).toEqual({
+      capacity: { desired: 'Desired cannot be smaller than Min' },
+    });
+    expect(validateEcsResizeValues({ capacity: { desired: 9, max: 8, min: 2 } })).toEqual({
+      capacity: { desired: 'Desired cannot be larger than Max' },
+    });
+    expect(validateEcsResizeValues({ capacity: { desired: 4, max: 8, min: 2 } })).toEqual({});
+  });
+
+  it('submits the exact shared resize writer contract through its task monitor', () => {
+    const app = application({ platformHealthOnly: true, platformHealthOnlyShowOverride: true });
+    const writer = { resizeServerGroup: jasmine.createSpy('resizeServerGroup').and.returnValue(Promise.resolve()) };
+    const component = new EcsResizeServerGroupModal(props(app));
+    (component as any).context = { services: { serverGroupWriter: writer } };
+    component.setState = ((update: any) => {
+      component.state = { ...component.state, ...(typeof update === 'function' ? update(component.state) : update) };
+    }) as any;
+    component.setState({ verified: true });
+    spyOn(component.state.taskMonitor, 'submit').and.callFake((submitMethod: any) => submitMethod());
+
+    (component as any).submit({
+      capacity: { desired: 6, max: 10, min: 3 },
+      interestingHealthProviderNames: ['Ecs'],
+      reason: '  preserve this resize reason exactly  ',
+    });
+
+    expect(component.state.taskMonitor.submit).toHaveBeenCalled();
+    expect(writer.resizeServerGroup).toHaveBeenCalledOnceWith(serverGroup, app, {
+      capacity: { desired: 6, max: 10, min: 3 },
+      interestingHealthProviderNames: ['Ecs'],
+      reason: '  preserve this resize reason exactly  ',
+    });
+  });
+
+  it('does not submit invalid or unverified resize commands', () => {
+    const writer = { resizeServerGroup: jasmine.createSpy('resizeServerGroup') };
+    const component = new EcsResizeServerGroupModal(props());
+    (component as any).context = { services: { serverGroupWriter: writer } };
+    spyOn(component.state.taskMonitor, 'submit');
+
+    (component as any).submit({ capacity: { desired: 9, max: 8, min: 2 } });
+    component.state.verified = true;
+    (component as any).submit({ capacity: { desired: 9, max: 8, min: 2 } });
+
+    expect(component.state.taskMonitor.submit).not.toHaveBeenCalled();
+    expect(writer.resizeServerGroup).not.toHaveBeenCalled();
+  });
+
+  it('renders task, capacity, verification, reason, and ECS platform-health controls', () => {
+    const app = application({ platformHealthOnly: true, platformHealthOnlyShowOverride: true });
+    const wrapper = shallow(<EcsResizeServerGroupModal {...props(app)} />);
+    const formik = wrapper.find(SpinFormik);
+    expect(wrapper.find(TaskMonitorWrapper).prop('monitor')).toBe((wrapper.instance() as any).state.taskMonitor);
+
+    const content = shallow(
+      <div>
+        {(formik.prop('render') as any)({
+          errors: {},
+          isValid: true,
+          setFieldValue: jasmine.createSpy('setFieldValue'),
+          values: formik.prop('initialValues'),
+        })}
+      </div>,
+    );
+
+    expect(content.find(UserVerification).prop('account')).toBe('test-account');
+    expect(content.find(TaskReason).exists()).toBe(true);
+    expect(content.find('[name="capacity.min"]').exists()).toBe(true);
+    expect(content.find('[name="capacity.max"]').exists()).toBe(true);
+    expect(content.find('[name="capacity.desired"]').exists()).toBe(true);
+    expect(content.find(PlatformHealthOverride).props()).toEqual(
+      jasmine.objectContaining({ interestingHealthProviderNames: ['Ecs'], platformHealthType: 'Ecs' }),
+    );
+  });
+
+  it('exports a show primitive for later actions integration', () => {
+    const show = spyOn(ReactModal, 'show').and.returnValue(Promise.resolve() as any);
+    const modalProps = props();
+    const runtimeServices = {} as any;
+
+    EcsResizeServerGroupModal.show(modalProps, runtimeServices);
+
+    expect(show).toHaveBeenCalledOnceWith(EcsResizeServerGroupModal, modalProps, undefined, runtimeServices);
+  });
+});

package/src/serverGroup/details/resize/EcsResizeServerGroupModal.tsx

@@ -0,0 +1,263 @@
+import React from 'react';
+import { Modal } from 'react-bootstrap';
+
+import type {
+  Application,
+  DeckRuntimeServices,
+  IModalComponentProps,
+  IServerGroup,
+  IServerGroupJob,
+} from '@spinnaker/core';
+import {
+  DeckRuntimeContext,
+  FormikFormField,
+  MinMaxDesiredChanges,
+  ModalClose,
+  noop,
+  NumberInput,
+  PlatformHealthOverride,
+  ReactModal,
+  SpinFormik,
+  TaskMonitor,
+  TaskMonitorWrapper,
+  TaskReason,
+  UserVerification,
+  ValidationMessage,
+} from '@spinnaker/core';
+
+export interface IEcsResizeServerGroupModalProps extends IModalComponentProps {
+  application: Application;
+  serverGroup: IServerGroup;
+}
+
+export interface IEcsResizeCapacity {
+  desired: number;
+  max: number;
+  min: number;
+}
+
+export interface IEcsResizeServerGroupValues {
+  capacity: IEcsResizeCapacity;
+  interestingHealthProviderNames?: string[];
+  reason?: string;
+}
+
+export interface IEcsResizeServerGroupJob extends IServerGroupJob {
+  capacity: IEcsResizeCapacity;
+  interestingHealthProviderNames?: string[];
+  reason?: string;
+}
+
+export interface IEcsResizeServerGroupErrors {
+  capacity?: Partial<Record<keyof IEcsResizeCapacity, string>>;
+}
+
+interface IEcsResizeServerGroupModalState {
+  initialValues: IEcsResizeServerGroupValues;
+  taskMonitor: TaskMonitor;
+  verified: boolean;
+}
+
+export function validateEcsResizeValues(values: IEcsResizeServerGroupValues): IEcsResizeServerGroupErrors {
+  const { desired, max, min } = values.capacity;
+  const capacity: IEcsResizeServerGroupErrors['capacity'] = {};
+
+  if (!Number.isFinite(min) || min < 0) {
+    capacity.min = 'Min cannot be negative';
+  }
+  if (!Number.isFinite(max) || max < 0) {
+    capacity.max = 'Max cannot be negative';
+  }
+  if (!Number.isFinite(desired) || desired < 0) {
+    capacity.desired = 'Desired cannot be negative';
+  }
+  if (Object.keys(capacity).length > 0) {
+    return { capacity };
+  }
+
+  if (min > max) {
+    capacity.min = 'Min cannot be larger than Max';
+    capacity.max = 'Max cannot be smaller than Min';
+  } else if (desired < min) {
+    capacity.desired = 'Desired cannot be smaller than Min';
+  } else if (desired > max) {
+    capacity.desired = 'Desired cannot be larger than Max';
+  }
+
+  return Object.keys(capacity).length > 0 ? { capacity } : {};
+}
+
+export class EcsResizeServerGroupModal extends React.Component<
+  IEcsResizeServerGroupModalProps,
+  IEcsResizeServerGroupModalState
+> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
+  public static defaultProps: Partial<IEcsResizeServerGroupModalProps> = {
+    closeModal: noop,
+    dismissModal: noop,
+  };
+
+  public static show(
+    props: IEcsResizeServerGroupModalProps,
+    runtimeServices: DeckRuntimeServices,
+  ): Promise<IEcsResizeServerGroupJob> {
+    return ReactModal.show(EcsResizeServerGroupModal, props, undefined, runtimeServices);
+  }
+
+  public constructor(props: IEcsResizeServerGroupModalProps) {
+    super(props);
+    const { application, serverGroup } = props;
+    const attributes = application.attributes || {};
+    this.state = {
+      initialValues: {
+        capacity: {
+          desired: Number(serverGroup.capacity.desired),
+          max: Number(serverGroup.capacity.max),
+          min: Number(serverGroup.capacity.min),
+        },
+        interestingHealthProviderNames:
+          attributes.platformHealthOnlyShowOverride && attributes.platformHealthOnly ? ['Ecs'] : undefined,
+      },
+      taskMonitor: new TaskMonitor({
+        application,
+        title: `Resizing ${serverGroup.name}`,
+        onDismiss: () => this.props.dismissModal(),
+        onTaskComplete: () => application.serverGroups.refresh(),
+      }),
+      verified: false,
+    };
+  }
+
+  private close = (): void => this.props.dismissModal();
+
+  private submit = (values: IEcsResizeServerGroupValues): void => {
+    if (!this.state.verified || Object.keys(validateEcsResizeValues(values)).length > 0) {
+      return;
+    }
+
+    const { application, serverGroup } = this.props;
+    const command: IEcsResizeServerGroupJob = {
+      capacity: values.capacity,
+      interestingHealthProviderNames: values.interestingHealthProviderNames,
+      reason: values.reason,
+    };
+    this.state.taskMonitor.submit(() =>
+      this.context.services.serverGroupWriter.resizeServerGroup(serverGroup, application, command),
+    );
+  };
+
+  private capacityError(errors: IEcsResizeServerGroupErrors): string | undefined {
+    const capacity = errors.capacity;
+    return capacity && ([capacity.min, capacity.max, capacity.desired].find(Boolean) as string);
+  }
+
+  public render(): JSX.Element {
+    const { application, serverGroup } = this.props;
+
+    return (
+      <>
+        <TaskMonitorWrapper monitor={this.state.taskMonitor} />
+        <SpinFormik<IEcsResizeServerGroupValues>
+          initialValues={this.state.initialValues}
+          onSubmit={this.submit}
+          validate={validateEcsResizeValues}
+          render={(formik) => {
+            const error = this.capacityError(formik.errors as IEcsResizeServerGroupErrors);
+            return (
+              <>
+                <ModalClose dismiss={this.close} />
+                <Modal.Header>
+                  <Modal.Title>Resize {serverGroup.name}</Modal.Title>
+                </Modal.Header>
+                <Modal.Body>
+                  <form className="form-horizontal">
+                    <div className="form-group bold">
+                      <div className="col-sm-2 col-sm-offset-3">Min</div>
+                      <div className="col-sm-2">Max</div>
+                      <div className="col-sm-2">Desired</div>
+                    </div>
+                    <div className="form-group">
+                      <div className="col-sm-3 sm-label-right">Current</div>
+                      {(['min', 'max', 'desired'] as Array<keyof IEcsResizeCapacity>).map((field) => (
+                        <div className="col-sm-2" key={field}>
+                          <input
+                            className="form-control input-sm"
+                            disabled={true}
+                            type="number"
+                            value={serverGroup.capacity[field]}
+                          />
+                        </div>
+                      ))}
+                    </div>
+                    <div className="form-group">
+                      <div className="col-sm-3 sm-label-right">Resize to</div>
+                      {(['min', 'max', 'desired'] as Array<keyof IEcsResizeCapacity>).map((field) => (
+                        <div className="col-sm-2" key={field}>
+                          <FormikFormField
+                            name={`capacity.${field}`}
+                            input={(props) => <NumberInput {...props} min={0} />}
+                            layout={({ input }) => <>{input}</>}
+                            touched={true}
+                          />
+                        </div>
+                      ))}
+                    </div>
+                    {error && (
+                      <div className="col-sm-9 col-sm-offset-3">
+                        <ValidationMessage message={error} type="error" />
+                      </div>
+                    )}
+
+                    <div className="form-group">
+                      <div className="col-sm-3 sm-label-right">Changes</div>
+                      <div className="col-sm-9 sm-control-field">
+                        <MinMaxDesiredChanges current={serverGroup.capacity} next={formik.values.capacity} />
+                      </div>
+                    </div>
+
+                    {application.attributes?.platformHealthOnlyShowOverride && (
+                      <div className="form-group">
+                        <div className="col-sm-10 col-sm-offset-1">
+                          <PlatformHealthOverride
+                            interestingHealthProviderNames={formik.values.interestingHealthProviderNames}
+                            onChange={(names) => formik.setFieldValue('interestingHealthProviderNames', names)}
+                            platformHealthType="Ecs"
+                            showHelpDetails={true}
+                          />
+                        </div>
+                      </div>
+                    )}
+
+                    <TaskReason
+                      reason={formik.values.reason}
+                      onChange={(reason) => formik.setFieldValue('reason', reason)}
+                    />
+                  </form>
+                </Modal.Body>
+                <Modal.Footer>
+                  <UserVerification
+                    account={serverGroup.account}
+                    onValidChange={(verified) => this.setState({ verified })}
+                  />
+                  <button className="btn btn-default" onClick={this.close} type="button">
+                    Cancel
+                  </button>
+                  <button
+                    className="btn btn-primary"
+                    disabled={!this.state.verified || !formik.isValid}
+                    onClick={() => this.submit(formik.values)}
+                    type="submit"
+                  >
+                    Submit
+                  </button>
+                </Modal.Footer>
+              </>
+            );
+          }}
+        />
+      </>
+    );
+  }
+}

package/src/serverGroup/details/resize/index.ts

@@ -0,0 +1 @@
+export * from './EcsResizeServerGroupModal';

package/src/serverGroup/details/rollback/EcsRollbackServerGroupModal.spec.tsx

@@ -0,0 +1,173 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import {
+  PlatformHealthOverride,
+  ReactModal,
+  SpinFormik,
+  TaskMonitorWrapper,
+  TaskReason,
+  UserVerification,
+} from '@spinnaker/core';
+
+import { EcsRollbackServerGroupModal, getEcsRollbackTargets, validateEcsRollbackValues } from './index';
+
+describe('EcsRollbackServerGroupModal', () => {
+  const serverGroup = {
+    account: 'test-account',
+    capacity: { desired: 4, max: 8, min: 2 },
+    cluster: 'fnord-main',
+    moniker: { app: 'fnord', cluster: 'fnord-main' },
+    name: 'fnord-main-v004',
+    region: 'eu-west-1',
+  };
+
+  function application(attributes: any = {}) {
+    return {
+      attributes,
+      name: 'fnord',
+      serverGroups: {
+        data: [
+          target('fnord-main-v003'),
+          target('fnord-main-v002', { isDisabled: false }),
+          target('other-main-v003', { cluster: 'other-main', moniker: { app: 'fnord', cluster: 'other-main' } }),
+          target('fnord-main-v003-other-account', { account: 'other-account' }),
+          target('fnord-main-v003-other-region', { region: 'us-east-1' }),
+          target('fnord-main-v003-other-app', { moniker: { app: 'other', cluster: 'fnord-main' } }),
+        ],
+        refresh: jasmine.createSpy('refresh'),
+      },
+    } as any;
+  }
+
+  function target(name: string, overrides: any = {}) {
+    return {
+      account: 'test-account',
+      cluster: 'fnord-main',
+      isDisabled: true,
+      moniker: { app: 'fnord', cluster: 'fnord-main' },
+      name,
+      region: 'eu-west-1',
+      ...overrides,
+    };
+  }
+
+  function props(app = application()) {
+    return {
+      application: app,
+      closeModal: jasmine.createSpy('closeModal'),
+      dismissModal: jasmine.createSpy('dismissModal'),
+      serverGroup: serverGroup as any,
+    };
+  }
+
+  it('finds only disabled rollback targets in the same application, cluster, account, and region', () => {
+    expect(getEcsRollbackTargets(application(), serverGroup as any).map((candidate) => candidate.name)).toEqual([
+      'fnord-main-v003',
+    ]);
+  });
+
+  it('requires a target and a health threshold from 0 through 100 while keeping reason optional', () => {
+    expect(validateEcsRollbackValues({ restoreServerGroupName: '', targetHealthyRollbackPercentage: 100 })).toEqual({
+      restoreServerGroupName: 'Select a server group to restore',
+    });
+    expect(
+      validateEcsRollbackValues({ restoreServerGroupName: 'fnord-main-v003', targetHealthyRollbackPercentage: -1 }),
+    ).toEqual({ targetHealthyRollbackPercentage: 'Healthy threshold must be between 0 and 100' });
+    expect(
+      validateEcsRollbackValues({ restoreServerGroupName: 'fnord-main-v003', targetHealthyRollbackPercentage: 101 }),
+    ).toEqual({ targetHealthyRollbackPercentage: 'Healthy threshold must be between 0 and 100' });
+    expect(
+      validateEcsRollbackValues({ restoreServerGroupName: 'fnord-main-v003', targetHealthyRollbackPercentage: 95 }),
+    ).toEqual({});
+    expect(
+      validateEcsRollbackValues({ restoreServerGroupName: 'fnord-main-v999', targetHealthyRollbackPercentage: 95 }, [
+        'fnord-main-v003',
+      ]),
+    ).toEqual({ restoreServerGroupName: 'Select an eligible server group to restore' });
+  });
+
+  it('does not submit a rollback target outside the eligible disabled set', () => {
+    const app = application();
+    const writer = { rollbackServerGroup: jasmine.createSpy('rollbackServerGroup') };
+    const component = new EcsRollbackServerGroupModal(props(app));
+    (component as any).context = { services: { serverGroupWriter: writer } };
+    component.state.verified = true;
+    spyOn(component.state.taskMonitor, 'submit');
+
+    (component as any).submit({
+      restoreServerGroupName: 'fnord-main-v999',
+      targetHealthyRollbackPercentage: 95,
+    });
+
+    expect(component.state.taskMonitor.submit).not.toHaveBeenCalled();
+    expect(writer.rollbackServerGroup).not.toHaveBeenCalled();
+  });
+
+  it('submits the exact shared rollback writer contract through its task monitor', () => {
+    const app = application({ platformHealthOnly: true, platformHealthOnlyShowOverride: true });
+    const writer = { rollbackServerGroup: jasmine.createSpy('rollbackServerGroup').and.returnValue(Promise.resolve()) };
+    const component = new EcsRollbackServerGroupModal(props(app));
+    (component as any).context = { services: { serverGroupWriter: writer } };
+    component.setState = ((update: any) => {
+      component.state = { ...component.state, ...(typeof update === 'function' ? update(component.state) : update) };
+    }) as any;
+    component.setState({ verified: true });
+    spyOn(component.state.taskMonitor, 'submit').and.callFake((submitMethod: any) => submitMethod());
+
+    (component as any).submit({
+      interestingHealthProviderNames: ['Ecs'],
+      reason: '  preserve this reason exactly  ',
+      restoreServerGroupName: 'fnord-main-v003',
+      targetHealthyRollbackPercentage: 95,
+    });
+
+    expect(component.state.taskMonitor.submit).toHaveBeenCalled();
+    expect(writer.rollbackServerGroup).toHaveBeenCalledOnceWith(serverGroup, app, {
+      interestingHealthProviderNames: ['Ecs'],
+      platformHealthOnlyShowOverride: true,
+      reason: '  preserve this reason exactly  ',
+      rollbackContext: {
+        restoreServerGroupName: 'fnord-main-v003',
+        rollbackServerGroupName: 'fnord-main-v004',
+        targetHealthyRollbackPercentage: 95,
+      },
+      rollbackType: 'EXPLICIT',
+    });
+  });
+
+  it('renders task, verification, reason, threshold, and ECS platform-health controls', () => {
+    const app = application({ platformHealthOnly: true, platformHealthOnlyShowOverride: true });
+    const wrapper = shallow(<EcsRollbackServerGroupModal {...props(app)} />);
+    const formik = wrapper.find(SpinFormik);
+    expect(wrapper.find(TaskMonitorWrapper).prop('monitor')).toBe((wrapper.instance() as any).state.taskMonitor);
+
+    const content = shallow(
+      <div>
+        {(formik.prop('render') as any)({
+          errors: {},
+          isValid: true,
+          setFieldValue: jasmine.createSpy('setFieldValue'),
+          values: formik.prop('initialValues'),
+        })}
+      </div>,
+    );
+
+    expect(content.find(UserVerification).prop('account')).toBe('test-account');
+    expect(content.find(TaskReason).exists()).toBe(true);
+    expect(content.find('input[name="targetHealthyRollbackPercentage"]').exists()).toBe(true);
+    expect(content.find(PlatformHealthOverride).props()).toEqual(
+      jasmine.objectContaining({ interestingHealthProviderNames: ['Ecs'], platformHealthType: 'Ecs' }),
+    );
+  });
+
+  it('exports a show primitive for later actions integration', () => {
+    const show = spyOn(ReactModal, 'show').and.returnValue(Promise.resolve() as any);
+    const modalProps = props();
+    const runtimeServices = {} as any;
+
+    EcsRollbackServerGroupModal.show(modalProps, runtimeServices);
+
+    expect(show).toHaveBeenCalledOnceWith(EcsRollbackServerGroupModal, modalProps, undefined, runtimeServices);
+  });
+});