@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/serverGroup/details/sections/AmazonServerGroupMaintenanceActions.spec.tsx

@@ -0,0 +1,148 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import type { Application, ISecurityGroup } from '@spinnaker/core';
+import { FirewallLabels } from '@spinnaker/core';
+
+import type { IAmazonServerGroupView } from '../../../domain';
+import { AWSProviderSettings } from '../../../aws.settings';
+import { EditAsgAdvancedSettingsModal } from '../advancedSettings';
+import { ModifyScalingProcessesModal } from '../scalingProcesses';
+import { EditScheduledActionsModal } from '../scheduledActions';
+import { EditSecurityGroupsModal } from '../securityGroups';
+import { AdvancedSettingsDetailsSection } from './AdvancedSettingsDetailsSection';
+import { ScalingProcessesDetailsSection } from './ScalingProcessesDetailsSection';
+import { ScheduledActionsDetailsSection } from './ScheduledActionsDetailsSection';
+import { SecurityGroupsDetailsSection } from './SecurityGroupsDetailsSection';
+
+describe('Amazon server group maintenance action integration', () => {
+  const originalAdHocInfraWritesEnabled = AWSProviderSettings.adHocInfraWritesEnabled;
+  const runtimeServices = {} as any;
+  const editSecurityGroupsLabel = `Edit ${FirewallLabels.get('Firewalls')}`;
+  const resolvedSecurityGroup = {
+    accountName: 'test-account',
+    id: 'sg-123',
+    name: 'application-security-group',
+    region: 'us-east-1',
+    vpcId: 'vpc-123',
+  } as ISecurityGroup;
+  const application = ({
+    name: 'test-app',
+    securityGroups: { data: [resolvedSecurityGroup] },
+    serverGroups: { refresh: jasmine.createSpy('refresh') },
+  } as any) as Application;
+  const serverGroup = {
+    account: 'test-account',
+    asg: {
+      defaultCooldown: 300,
+      enabledMetrics: [],
+      healthCheckGracePeriod: 0,
+      healthCheckType: 'EC2',
+      suspendedProcesses: [],
+      terminationPolicies: ['Default'],
+    },
+    name: 'test-app-main-v001',
+    region: 'us-east-1',
+    scalingPolicies: [],
+    scheduledActions: [],
+    securityGroups: ['sg-123'],
+    type: 'aws',
+    vpcId: 'vpc-123',
+  } as IAmazonServerGroupView;
+
+  const editLink = (wrapper: ReturnType<typeof shallow>, label: string) =>
+    wrapper.find('a.clickable').filterWhere((link) => link.text() === label);
+
+  const withRuntimeServices = <T extends React.Component>(wrapper: ReturnType<typeof shallow>) => {
+    (wrapper.instance() as T).context = { services: runtimeServices };
+    return wrapper;
+  };
+
+  beforeEach(() => {
+    AWSProviderSettings.adHocInfraWritesEnabled = true;
+  });
+
+  afterEach(() => {
+    AWSProviderSettings.adHocInfraWritesEnabled = originalAdHocInfraWritesEnabled;
+  });
+
+  it('opens Advanced Settings with the exact application and enriched server group', () => {
+    const show = spyOn(EditAsgAdvancedSettingsModal, 'show');
+    const wrapper = withRuntimeServices(
+      shallow(<AdvancedSettingsDetailsSection app={application} serverGroup={serverGroup} />),
+    );
+
+    editLink(wrapper, 'Edit Advanced Settings').simulate('click');
+
+    expect(show).toHaveBeenCalledOnceWith({ application, serverGroup }, runtimeServices);
+  });
+
+  it('opens Scaling Processes with the exact application and enriched server group', () => {
+    const show = spyOn(ModifyScalingProcessesModal, 'show');
+    const wrapper = shallow(<ScalingProcessesDetailsSection app={application} serverGroup={serverGroup} />);
+
+    editLink(wrapper, 'Edit Scaling Processes').simulate('click');
+
+    expect(show).toHaveBeenCalledOnceWith({ application, serverGroup });
+  });
+
+  it('opens Scheduled Actions with the exact application and enriched server group', () => {
+    const show = spyOn(EditScheduledActionsModal, 'show');
+    const wrapper = shallow(<ScheduledActionsDetailsSection app={application} serverGroup={serverGroup} />);
+
+    editLink(wrapper, 'Edit Scheduled Actions').simulate('click');
+
+    expect(show).toHaveBeenCalledOnceWith({ application, serverGroup });
+  });
+
+  it('opens Security Groups with resolved groups and exact application and enriched server group', () => {
+    const show = spyOn(EditSecurityGroupsModal, 'show');
+    const wrapper = withRuntimeServices(
+      shallow(<SecurityGroupsDetailsSection app={application} serverGroup={serverGroup} />),
+    );
+
+    editLink(wrapper, editSecurityGroupsLabel).simulate('click');
+
+    expect(show).toHaveBeenCalledOnceWith(
+      { application, securityGroups: [resolvedSecurityGroup], serverGroup },
+      runtimeServices,
+    );
+  });
+
+  it('hides all maintenance links when ad-hoc infrastructure writes are disabled', () => {
+    AWSProviderSettings.adHocInfraWritesEnabled = false;
+
+    expect(
+      editLink(
+        shallow(<AdvancedSettingsDetailsSection app={application} serverGroup={serverGroup} />),
+        'Edit Advanced Settings',
+      ).length,
+    ).toBe(0);
+    expect(
+      editLink(
+        shallow(<ScalingProcessesDetailsSection app={application} serverGroup={serverGroup} />),
+        'Edit Scaling Processes',
+      ).length,
+    ).toBe(0);
+    expect(
+      editLink(
+        shallow(<ScheduledActionsDetailsSection app={application} serverGroup={serverGroup} />),
+        'Edit Scheduled Actions',
+      ).length,
+    ).toBe(0);
+    expect(
+      editLink(
+        shallow(<SecurityGroupsDetailsSection app={application} serverGroup={serverGroup} />),
+        editSecurityGroupsLabel,
+      ).length,
+    ).toBe(0);
+  });
+
+  it('hides Security Groups editing when the server group has no VPC', () => {
+    const wrapper = shallow(
+      <SecurityGroupsDetailsSection app={application} serverGroup={{ ...serverGroup, vpcId: undefined }} />,
+    );
+
+    expect(editLink(wrapper, editSecurityGroupsLabel).length).toBe(0);
+  });
+});

package/src/serverGroup/details/sections/InstancesDistributionDetailsSection.spec.tsx

@@ -2,17 +2,13 @@ import { shallow } from 'enzyme';
 import React from 'react';
 
 import type { Application } from '@spinnaker/core';
-import { ApplicationModelBuilder } from '@spinnaker/core';
 import { mockLaunchTemplate, mockServerGroup } from '@spinnaker/mocks';
 
 import type { IAmazonMixedInstancesPolicy, IAmazonServerGroupView, IScalingPolicy } from '../../../domain';
 import { InstancesDistributionDetailsSection } from '../../../index';
 
 describe('InstancesDistribution', () => {
-  let app: Application;
-  beforeEach(() => {
-    app = ApplicationModelBuilder.createApplicationForTests('testapp');
-  });
+  const app = {} as Application;
 
   const serverGroupWithMip = {
     ...mockServerGroup,

package/src/serverGroup/details/sections/LaunchTemplateDetailsSection.spec.tsx

@@ -2,7 +2,6 @@ import { shallow } from 'enzyme';
 import React from 'react';
 
 import type { Application } from '@spinnaker/core';
-import { ApplicationModelBuilder } from '@spinnaker/core';
 import {
   createCustomMockLaunchTemplate,
   mockLaunchTemplate,
@@ -15,10 +14,7 @@ import { MultipleInstanceTypesSubSection } from './MultipleInstanceTypesSubSecti
 import type { IAmazonMixedInstancesPolicy, IAmazonServerGroupView, IScalingPolicy } from '../../../domain';
 
 describe('Launch template details', () => {
-  let app: Application;
-  beforeEach(() => {
-    app = ApplicationModelBuilder.createApplicationForTests('testapp');
-  });
+  const app = {} as Application;
 
   const baseServerGroupWithLt = {
     ...mockServerGroup,

package/src/serverGroup/details/sections/ScalingProcessesDetailsSection.tsx

@@ -1,11 +1,11 @@
 import React from 'react';
 
-import { CollapsibleSection, confirmNotManaged, HelpField, ModalInjector, timestamp, Tooltip } from '@spinnaker/core';
+import { CollapsibleSection, HelpField, timestamp, Tooltip } from '@spinnaker/core';
 
 import type { IAmazonServerGroupDetailsSectionProps } from './IAmazonServerGroupDetailsSectionProps';
 import { AWSProviderSettings } from '../../../aws.settings';
 import type { IScalingProcess } from '../../../domain';
-import { AutoScalingProcessService } from '../scalingProcesses/AutoScalingProcessService';
+import { AutoScalingProcessService, ModifyScalingProcessesModal } from '../scalingProcesses';
 
 export interface IScalingProcessesDetailsSectionState {
   autoScalingProcesses: IScalingProcess[];
@@ -23,23 +23,6 @@ export class ScalingProcessesDetailsSection extends React.Component<
     this.state = this.getState(props);
   }
 
-  private toggleScalingProcesses = (): void => {
-    const { app, serverGroup } = this.props;
-    confirmNotManaged(serverGroup, app).then(
-      (isNotManaged) =>
-        isNotManaged &&
-        ModalInjector.modalService.open({
-          templateUrl: require('../scalingProcesses/modifyScalingProcesses.html'),
-          controller: 'ModifyScalingProcessesCtrl as ctrl',
-          resolve: {
-            serverGroup: () => serverGroup,
-            application: () => app,
-            processes: () => this.state.autoScalingProcesses,
-          },
-        }),
-    );
-  };
-
   private getState(props: IAmazonServerGroupDetailsSectionProps): IScalingProcessesDetailsSectionState {
     const { serverGroup } = props;
 
@@ -63,6 +46,11 @@ export class ScalingProcessesDetailsSection extends React.Component<
     this.setState(this.getState(nextProps));
   }
 
+  private editScalingProcesses = (): void => {
+    const { app: application, serverGroup } = this.props;
+    ModifyScalingProcessesModal.show({ application, serverGroup });
+  };
+
   public render(): JSX.Element {
     const { autoScalingProcesses, scalingPoliciesDisabled, scheduledActionsDisabled } = this.state;
 
@@ -103,7 +91,7 @@ export class ScalingProcessesDetailsSection extends React.Component<
           ))}
         </ul>
         {AWSProviderSettings.adHocInfraWritesEnabled && (
-          <a className="clickable" onClick={this.toggleScalingProcesses}>
+          <a className="clickable" onClick={this.editScalingProcesses}>
             Edit Scaling Processes
           </a>
         )}

package/src/serverGroup/details/sections/ScheduledActionsDetailsSection.tsx

@@ -1,12 +1,13 @@
 import React from 'react';
 
-import { CollapsibleSection, ModalInjector, Tooltip } from '@spinnaker/core';
+import { CollapsibleSection, Tooltip } from '@spinnaker/core';
 
 import type { IAmazonServerGroupDetailsSectionProps } from './IAmazonServerGroupDetailsSectionProps';
 import { AWSProviderSettings } from '../../../aws.settings';
 import type { IScalingProcess } from '../../../domain';
 import { AutoScalingProcessService } from '../scalingProcesses/AutoScalingProcessService';
 import { ScheduledAction } from '../scheduledAction/ScheduledAction';
+import { EditScheduledActionsModal } from '../scheduledActions';
 
 export interface IScheduledActionsDetailsSectionState {
   scheduledActionsDisabled: boolean;
@@ -35,21 +36,15 @@ export class ScheduledActionsDetailsSection extends React.Component<
     return { scheduledActionsDisabled };
   }
 
-  private editScheduledActions = (): void => {
-    ModalInjector.modalService.open({
-      templateUrl: require('../scheduledAction/editScheduledActions.modal.html'),
-      controller: 'EditScheduledActionsCtrl as ctrl',
-      resolve: {
-        application: () => this.props.app,
-        serverGroup: () => this.props.serverGroup,
-      },
-    });
-  };
-
   public componentWillReceiveProps(nextProps: IAmazonServerGroupDetailsSectionProps): void {
     this.setState(this.getState(nextProps));
   }
 
+  private editScheduledActions = (): void => {
+    const { app: application, serverGroup } = this.props;
+    EditScheduledActionsModal.show({ application, serverGroup });
+  };
+
   public render(): JSX.Element {
     const { serverGroup } = this.props;
     const { scheduledActionsDisabled } = this.state;

package/src/serverGroup/details/sections/SecurityGroupsDetailsSection.tsx

@@ -3,11 +3,12 @@ import { chain, find, sortBy } from 'lodash';
 import React from 'react';
 
 import type { ISecurityGroup, ISecurityGroupsByAccount } from '@spinnaker/core';
-import { CollapsibleSection, confirmNotManaged, FirewallLabels, ModalInjector } from '@spinnaker/core';
+import { CollapsibleSection, DeckRuntimeContext, FirewallLabels } from '@spinnaker/core';
 
 import type { IAmazonServerGroupDetailsSectionProps } from './IAmazonServerGroupDetailsSectionProps';
 import { AWSProviderSettings } from '../../../aws.settings';
 import { AwsSecurityGroupReader } from '../../../securityGroup/securityGroup.reader';
+import { EditSecurityGroupsModal } from '../securityGroups';
 
 export interface ISecurityGroupsDetailsSectionState {
   securityGroups: ISecurityGroup[];
@@ -17,6 +18,9 @@ export class SecurityGroupsDetailsSection extends React.Component<
   IAmazonServerGroupDetailsSectionProps,
   ISecurityGroupsDetailsSectionState
 > {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
   constructor(props: IAmazonServerGroupDetailsSectionProps) {
     super(props);
 
@@ -61,27 +65,18 @@ export class SecurityGroupsDetailsSection extends React.Component<
     return securityGroups;
   }
 
-  private updateSecurityGroups = (): void => {
-    const { app, serverGroup } = this.props;
-    confirmNotManaged(serverGroup, app).then(
-      (notManaged) =>
-        notManaged &&
-        ModalInjector.modalService.open({
-          templateUrl: require('../securityGroup/editSecurityGroups.modal.html'),
-          controller: 'EditSecurityGroupsCtrl as $ctrl',
-          resolve: {
-            application: () => app,
-            serverGroup: () => serverGroup,
-            securityGroups: () => this.state.securityGroups,
-          },
-        }),
-    );
-  };
-
   public componentWillReceiveProps(nextProps: IAmazonServerGroupDetailsSectionProps): void {
     this.setState({ securityGroups: this.getSecurityGroups(nextProps) });
   }
 
+  private editSecurityGroups = (): void => {
+    const { app: application, serverGroup } = this.props;
+    EditSecurityGroupsModal.show(
+      { application, securityGroups: this.state.securityGroups, serverGroup },
+      this.context.services,
+    );
+  };
+
   public render(): JSX.Element {
     const { serverGroup } = this.props;
     const { securityGroups } = this.state;
@@ -109,7 +104,7 @@ export class SecurityGroupsDetailsSection extends React.Component<
           ))}
         </ul>
         {AWSProviderSettings.adHocInfraWritesEnabled && serverGroup.vpcId && (
-          <a className="clickable" onClick={this.updateSecurityGroups}>
+          <a className="clickable" onClick={this.editSecurityGroups}>
             Edit {FirewallLabels.get('Firewalls')}
           </a>
         )}

package/src/serverGroup/details/sections/WarmPoolDetailsSection.tsx

@@ -0,0 +1,44 @@
+import React from 'react';
+
+import { CollapsibleSection } from '@spinnaker/core';
+
+import type { IAmazonServerGroupDetailsSectionProps } from './IAmazonServerGroupDetailsSectionProps';
+import { AWSProviderSettings } from '../../../aws.settings';
+import { ModifyWarmPoolModal, WarmPoolService } from '../warmPool';
+
+export class WarmPoolDetailsSection extends React.Component<IAmazonServerGroupDetailsSectionProps> {
+  private editWarmPool = (): void => {
+    const { app: application, serverGroup } = this.props;
+    ModifyWarmPoolModal.show({ application, serverGroup });
+  };
+
+  public render(): JSX.Element {
+    const { serverGroup } = this.props;
+    const configuration = WarmPoolService.getWarmPoolConfiguration(serverGroup);
+
+    return (
+      <CollapsibleSection cacheKey="Warm Pool" heading="Warm Pool">
+        {configuration ? (
+          <ul className="warm-pool">
+            <li>Min Size: {configuration.minSize ?? 0}</li>
+            <li>
+              Max Group Prepared Capacity:{' '}
+              {configuration.maxGroupPreparedCapacity != null && configuration.maxGroupPreparedCapacity >= 0
+                ? configuration.maxGroupPreparedCapacity
+                : 'No limit'}
+            </li>
+            <li>Instance State: {configuration.poolState ?? 'Stopped'}</li>
+            <li>Reuse on Scale In: {configuration.instanceReusePolicy?.reuseOnScaleIn ? 'Yes' : 'No'}</li>
+          </ul>
+        ) : (
+          <div className="text-disabled">No warm pool configured</div>
+        )}
+        {AWSProviderSettings.adHocInfraWritesEnabled && (
+          <a className="clickable" onClick={this.editWarmPool}>
+            Edit Warm Pool
+          </a>
+        )}
+      </CollapsibleSection>
+    );
+  }
+}

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

@@ -13,3 +13,4 @@ export * from './ScalingProcessesDetailsSection';
 export * from './ScheduledActionsDetailsSection';
 export * from './SecurityGroupsDetailsSection';
 export * from './TagsDetailsSection';
+export * from './WarmPoolDetailsSection';

package/src/serverGroup/details/securityGroups/EditSecurityGroupsModal.spec.tsx

@@ -0,0 +1,161 @@
+import { mount as enzymeMount } from 'enzyme';
+import React from 'react';
+import Select from 'react-select';
+import { of } from 'rxjs';
+
+import { AccountService, DeckRuntimeContext } from '@spinnaker/core';
+
+import { AwsModalFooter } from '../../../common/AwsModalFooter';
+
+import {
+  EditSecurityGroupsModal,
+  filterSecurityGroupsForServerGroup,
+  isLaunchTemplateBacked,
+} from './EditSecurityGroupsModal';
+
+describe('EditSecurityGroupsModal', () => {
+  let originalAccounts: typeof AccountService.accounts$;
+  let runtimeServices: any;
+  const RuntimeWrapper = ({ children }: React.PropsWithChildren<{}>) => (
+    <DeckRuntimeContext.Provider value={{ services: runtimeServices } as any}>{children}</DeckRuntimeContext.Provider>
+  );
+  const shallowModal = (props: any) =>
+    enzymeMount(<EditSecurityGroupsModal {...props} />, { wrappingComponent: RuntimeWrapper });
+
+  beforeEach(() => {
+    originalAccounts = AccountService.accounts$;
+    AccountService.accounts$ = of([]);
+    runtimeServices = {};
+  });
+
+  afterEach(() => {
+    AccountService.accounts$ = originalAccounts;
+  });
+
+  const serverGroup = {
+    name: 'deck-main-v001',
+    account: 'test',
+    region: 'us-east-1',
+    vpcId: 'vpc-1',
+  } as any;
+
+  const application = { name: 'deck', serverGroups: { refresh: jasmine.createSpy('refresh') } } as any;
+  const modalProps = {
+    application,
+    serverGroup,
+    closeModal: jasmine.createSpy('closeModal'),
+    dismissModal: jasmine.createSpy('dismissModal'),
+  };
+
+  async function flush(): Promise<void> {
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+
+  it('filters by account, region, and VPC while preserving unresolved attached groups', () => {
+    const attached = [
+      { id: 'sg-attached', name: 'attached' },
+      { id: 'sg-unresolved', name: 'sg-unresolved' },
+    ] as any;
+    const allGroups = {
+      test: {
+        aws: {
+          'us-east-1': [
+            { id: 'sg-attached', name: 'attached', vpcId: 'vpc-1' },
+            { id: 'sg-available', name: 'available', vpcId: 'vpc-1' },
+            { id: 'sg-wrong-vpc', name: 'wrong-vpc', vpcId: 'vpc-2' },
+          ],
+          'eu-west-1': [{ id: 'sg-wrong-region', name: 'wrong-region', vpcId: 'vpc-1' }],
+        },
+      },
+      other: { aws: { 'us-east-1': [{ id: 'sg-wrong-account', name: 'wrong-account', vpcId: 'vpc-1' }] } },
+    } as any;
+
+    expect(filterSecurityGroupsForServerGroup(allGroups, serverGroup, attached).map((group) => group.id)).toEqual([
+      'sg-attached',
+      'sg-unresolved',
+      'sg-available',
+    ]);
+  });
+
+  it('treats direct and mixed-instance launch templates as launch-template-backed', () => {
+    expect(isLaunchTemplateBacked({ launchTemplate: {} } as any)).toBe(true);
+    expect(isLaunchTemplateBacked({ mixedInstancesPolicy: {} } as any)).toBe(true);
+    expect(isLaunchTemplateBacked({ launchConfig: {} } as any)).toBe(false);
+  });
+
+  it('shows a retryable error without losing selections and recovers after retry', async () => {
+    const selected = [{ id: 'sg-attached', name: 'attached' }] as any;
+    const allGroups = {
+      test: { aws: { 'us-east-1': [{ id: 'sg-available', name: 'available', vpcId: 'vpc-1' }] } },
+    };
+    const getAllSecurityGroups = jasmine
+      .createSpy('getAllSecurityGroups')
+      .and.returnValues(Promise.reject(new Error('inventory unavailable')), Promise.resolve(allGroups));
+    runtimeServices.securityGroupReader = { getAllSecurityGroups };
+    const wrapper = shallowModal({ ...modalProps, securityGroups: selected });
+    await flush();
+    wrapper.update();
+
+    expect(wrapper.find(Select).prop('isLoading')).toBe(false);
+    expect(wrapper.find('.security-groups-load-error').text()).toContain('Unable to load');
+    expect(wrapper.find(AwsModalFooter).prop('isValid')).toBe(false);
+    expect(wrapper.state('securityGroups')).toEqual(selected);
+
+    wrapper.find('.security-groups-load-error button').simulate('click');
+    expect(wrapper.find(Select).prop('isLoading')).toBe(true);
+    await flush();
+    wrapper.update();
+
+    expect(getAllSecurityGroups).toHaveBeenCalledTimes(2);
+    expect(wrapper.find('.security-groups-load-error').length).toBe(0);
+    expect(wrapper.find(AwsModalFooter).prop('isValid')).toBe(true);
+    expect(wrapper.state('securityGroups')).toEqual(selected);
+    expect((wrapper.state('availableSecurityGroups') as any[]).map((group) => group.id)).toEqual([
+      'sg-attached',
+      'sg-available',
+    ]);
+  });
+
+  it('does not update state when security-group loading completes after unmount', async () => {
+    let finishLoading: (groups: any) => void;
+    const getAllSecurityGroups = jasmine.createSpy('getAllSecurityGroups').and.returnValue(
+      new Promise((resolve) => {
+        finishLoading = resolve;
+      }),
+    );
+    runtimeServices.securityGroupReader = { getAllSecurityGroups };
+    const wrapper = shallowModal(modalProps);
+    const modal = wrapper.instance() as EditSecurityGroupsModal;
+    const setState = spyOn(modal, 'setState').and.callThrough();
+
+    wrapper.unmount();
+    finishLoading({});
+    await flush();
+
+    expect(setState).not.toHaveBeenCalled();
+  });
+
+  it('submits selected groups through the writer with mixed-instance launch-template state', () => {
+    const update = jasmine.createSpy('updateSecurityGroups').and.returnValue(Promise.resolve({} as any));
+    const selected = [{ id: 'sg-attached', name: 'attached' }] as any;
+    const modal = new EditSecurityGroupsModal({
+      application,
+      securityGroups: selected,
+      serverGroup: { ...serverGroup, mixedInstancesPolicy: {} },
+      closeModal: jasmine.createSpy('closeModal'),
+      dismissModal: jasmine.createSpy('dismissModal'),
+    } as any) as any;
+    modal.context = { services: { serverGroupWriter: { updateSecurityGroups: update } } };
+    modal.state.taskMonitor = { submit: (method: () => any) => method() };
+
+    modal.submit();
+
+    expect(update).toHaveBeenCalledWith(
+      jasmine.objectContaining({ name: 'deck-main-v001' }),
+      selected,
+      application,
+      true,
+    );
+  });
+});