@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/routerConsumers.spec.tsx

@@ -0,0 +1,207 @@
+import { CreateApplicationLoadBalancerComponent } from './loadBalancer/configure/application/CreateApplicationLoadBalancer';
+import { CreateClassicLoadBalancerComponent } from './loadBalancer/configure/classic/CreateClassicLoadBalancer';
+import { CreateNetworkLoadBalancerComponent } from './loadBalancer/configure/network/CreateNetworkLoadBalancer';
+import { CreateLambdaFunctionComponent } from './function/CreateLambdaFunction';
+import { AmazonSecurityGroupModalComponent } from './securityGroup/configure/AmazonSecurityGroupModal';
+import { AmazonCloneServerGroupModalComponent } from './serverGroup/configure/wizard/AmazonCloneServerGroupModal';
+
+describe('Amazon routed modal consumers', () => {
+  function stateService(includedState: string) {
+    return {
+      go: jasmine.createSpy('go'),
+      includes: jasmine.createSpy('includes').and.callFake((state: string) => state === includedState),
+    };
+  }
+
+  [
+    ['application', CreateApplicationLoadBalancerComponent],
+    ['classic', CreateClassicLoadBalancerComponent],
+    ['network', CreateNetworkLoadBalancerComponent],
+  ].forEach(([type, Component]: [string, any]) => {
+    it(`navigates from the ${type} load balancer modal through its injected state service`, () => {
+      const state = stateService('**.loadBalancerDetails');
+      const modal = Object.create(Component.prototype) as any;
+      modal.props = { dismissModal: jasmine.createSpy('dismissModal'), stateService: state };
+      modal.state = {};
+      modal.setState = jasmine.createSpy('setState');
+
+      modal.onApplicationRefresh({
+        credentials: 'test-account',
+        name: 'fnord-main',
+        region: 'eu-west-1',
+        vpcId: 'vpc-1',
+      });
+
+      expect(state.go).toHaveBeenCalledWith('^.loadBalancerDetails', {
+        accountId: 'test-account',
+        name: 'fnord-main',
+        provider: 'aws',
+        region: 'eu-west-1',
+        vpcId: 'vpc-1',
+      });
+    });
+  });
+
+  [
+    ['application load balancer', CreateApplicationLoadBalancerComponent, 'loadBalancers'],
+    ['classic load balancer', CreateClassicLoadBalancerComponent, 'loadBalancers'],
+    ['network load balancer', CreateNetworkLoadBalancerComponent, 'loadBalancers'],
+    ['Lambda function', CreateLambdaFunctionComponent, 'functions'],
+  ].forEach(([type, Component, dataSourceName]: [string, any, string]) => {
+    it(`owns the ${type} refresh subscription across replacement and unmount`, () => {
+      const firstUnsubscribe = jasmine.createSpy('firstUnsubscribe');
+      const secondUnsubscribe = jasmine.createSpy('secondUnsubscribe');
+      const callbacks: Array<() => void> = [];
+      const onNextRefresh = jasmine.createSpy('onNextRefresh').and.callFake((callback: () => void) => {
+        callbacks.push(callback);
+        return callbacks.length === 1 ? firstUnsubscribe : secondUnsubscribe;
+      });
+      const refresh = jasmine.createSpy('refresh');
+      const state = stateService('');
+      const modal = Object.create(Component.prototype) as any;
+      modal.props = {
+        app: { [dataSourceName]: { onNextRefresh, refresh } },
+        dismissModal: jasmine.createSpy('dismissModal'),
+        stateService: state,
+      };
+      modal.state = {};
+      modal.setState = jasmine.createSpy('setState');
+
+      modal.onTaskComplete({});
+
+      expect(onNextRefresh.calls.first().invocationOrder).toBeLessThan(refresh.calls.first().invocationOrder);
+
+      modal.onTaskComplete({});
+
+      expect(firstUnsubscribe).toHaveBeenCalledTimes(1);
+
+      modal.componentWillUnmount();
+      callbacks[1]();
+
+      expect(secondUnsubscribe).toHaveBeenCalledTimes(1);
+      expect(modal.refreshUnsubscribe).toBeUndefined();
+      expect(state.go).not.toHaveBeenCalled();
+    });
+  });
+
+  it('navigates from the function modal through its injected state service', () => {
+    const state = stateService('');
+    const modal = Object.create(CreateLambdaFunctionComponent.prototype) as any;
+    modal.props = { dismissModal: jasmine.createSpy('dismissModal'), stateService: state };
+    modal.state = {};
+    modal.setState = jasmine.createSpy('setState');
+
+    modal.onApplicationRefresh({ credentials: 'test-account', name: 'fnord', region: 'eu-west-1', vpcId: 'vpc-1' });
+
+    expect(state.go).toHaveBeenCalledWith('.functionDetails', {
+      accountId: 'test-account',
+      name: 'fnord',
+      provider: 'aws',
+      region: 'eu-west-1',
+      vpcId: 'vpc-1',
+    });
+  });
+
+  it('navigates from the security group modal through its injected state service', () => {
+    const state = stateService('**.firewallDetails');
+    const refresh = jasmine.createSpy('refresh');
+    const closeModal = jasmine.createSpy('closeModal');
+    const modal = new AmazonSecurityGroupModalComponent({
+      app: { securityGroups: { refresh } },
+      closeModal,
+      dismissModal: jasmine.createSpy('dismissModal'),
+      mode: 'clone',
+      stateService: state,
+    } as any) as any;
+    modal.state = {
+      securityGroup: {
+        credentials: 'test-account',
+        name: 'fnord-firewall',
+        region: 'eu-west-1',
+        vpcId: 'vpc-1',
+      },
+    };
+
+    modal.onTaskComplete();
+
+    expect(refresh).toHaveBeenCalled();
+    expect(closeModal).toHaveBeenCalled();
+    expect(state.go).toHaveBeenCalledWith('^.firewallDetails', {
+      accountId: 'test-account',
+      name: 'fnord-firewall',
+      provider: 'aws',
+      region: 'eu-west-1',
+      vpcId: 'vpc-1',
+    });
+  });
+
+  it('navigates from the clone server group modal through its injected state service', () => {
+    const state = stateService('**.clusters');
+    const modal = new AmazonCloneServerGroupModalComponent({
+      application: { name: 'fnord' },
+      command: {
+        credentials: 'test-account',
+        region: 'eu-west-1',
+        viewState: { requiresTemplateSelection: true },
+      },
+      dismissModal: jasmine.createSpy('dismissModal'),
+      stateService: state,
+    } as any) as any;
+    modal.state = {
+      taskMonitor: {
+        task: {
+          execution: {
+            stages: [
+              {
+                context: { 'deploy.server.groups': { 'eu-west-1': 'fnord-main-v042' } },
+                type: 'cloneServerGroup',
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    modal.onApplicationRefresh();
+
+    expect(state.go).toHaveBeenCalledWith('.serverGroup', {
+      accountId: 'test-account',
+      provider: 'aws',
+      region: 'eu-west-1',
+      serverGroup: 'fnord-main-v042',
+    });
+  });
+
+  it('owns the clone server group refresh subscription across replacement and unmount', () => {
+    const firstUnsubscribe = jasmine.createSpy('firstUnsubscribe');
+    const secondUnsubscribe = jasmine.createSpy('secondUnsubscribe');
+    const callbacks: Array<() => void> = [];
+    const onNextRefresh = jasmine.createSpy('onNextRefresh').and.callFake((callback: () => void) => {
+      callbacks.push(callback);
+      return callbacks.length === 1 ? firstUnsubscribe : secondUnsubscribe;
+    });
+    const refresh = jasmine.createSpy('refresh');
+    const state = stateService('**.clusters');
+    const modal = new AmazonCloneServerGroupModalComponent({
+      application: { name: 'fnord', serverGroups: { onNextRefresh, refresh } },
+      command: { credentials: 'test-account', region: 'eu-west-1', viewState: { requiresTemplateSelection: true } },
+      dismissModal: jasmine.createSpy('dismissModal'),
+      stateService: state,
+    } as any) as any;
+
+    modal.onTaskComplete();
+
+    expect(onNextRefresh.calls.first().invocationOrder).toBeLessThan(refresh.calls.first().invocationOrder);
+
+    modal.onTaskComplete();
+
+    expect(firstUnsubscribe).toHaveBeenCalledTimes(1);
+
+    modal.componentWillUnmount();
+    callbacks[1]();
+
+    expect(secondUnsubscribe).toHaveBeenCalledTimes(1);
+    expect(modal.refreshUnsubscribe).toBeUndefined();
+    expect(state.go).not.toHaveBeenCalled();
+  });
+});

package/src/search/searchResultFormatter.ts

@@ -1,19 +1,12 @@
-import { module } from 'angular';
-
-import type { ISecurityGroupSearchResult } from '@spinnaker/core';
-import type { ISearchResultFormatter } from '@spinnaker/core';
+import type { ISearchResultFormatter, ISecurityGroupSearchResult } from '@spinnaker/core';
 
 import { VpcReader } from '../vpc/VpcReader';
 
-export const AMAZON_SEARCH_SEARCHRESULTFORMATTER = 'spinnaker.amazon.search.searchResultFormatter';
-export const name = AMAZON_SEARCH_SEARCHRESULTFORMATTER; // for backwards compatibility
-module(AMAZON_SEARCH_SEARCHRESULTFORMATTER, []).factory('awsSearchResultFormatter', function () {
-  return {
-    securityGroups: function (entry: ISecurityGroupSearchResult) {
-      return VpcReader.getVpcName(entry.vpcId).then(function (vpcName) {
-        const region = vpcName ? entry.region + ' - ' + vpcName.toLowerCase() : entry.region;
-        return entry.name + ' (' + region + ')';
-      });
-    } as ISearchResultFormatter,
-  };
-});
+export const awsSearchResultFormatter: { securityGroups: ISearchResultFormatter } = {
+  securityGroups: (entry: ISecurityGroupSearchResult) => {
+    return VpcReader.getVpcName(entry.vpcId).then((vpcName) => {
+      const region = vpcName ? entry.region + ' - ' + vpcName.toLowerCase() : entry.region;
+      return entry.name + ' (' + region + ')';
+    });
+  },
+};

package/src/securityGroup/configure/AmazonSecurityGroupModal.spec.tsx

@@ -0,0 +1,170 @@
+import { SecurityGroupWriter } from '@spinnaker/core';
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import {
+  AmazonSecurityGroupModalComponent as AmazonSecurityGroupModal,
+  initializeAmazonSecurityGroupForModal,
+  isAmazonSecurityGroupValid,
+} from './AmazonSecurityGroupModal';
+
+describe('AmazonSecurityGroupModal', () => {
+  function inferredSecurityGroup() {
+    return {
+      accountId: 'target-account-id',
+      accountName: 'target-account',
+      inboundRules: [
+        {
+          portRanges: [{ startPort: 443, endPort: 443 }],
+          protocol: 'tcp',
+          securityGroup: {
+            account: 'source-account',
+            accountId: 'source-account-id',
+            accountName: 'source-account-name',
+            id: 'sg-123456',
+            inferredName: true,
+            name: 'inferred-name',
+            vpcId: 'vpc-source',
+          },
+        },
+      ],
+      name: 'target-group',
+      region: 'us-east-1',
+      vpcId: 'vpc-target',
+    };
+  }
+
+  function buildModal(securityGroup: any, mode = 'edit'): any {
+    const modal = new AmazonSecurityGroupModal({
+      app: { name: 'fnord' },
+      closeModal: jasmine.createSpy('closeModal'),
+      dismissModal: jasmine.createSpy('dismissModal'),
+      mode,
+      securityGroup,
+    } as any) as any;
+    modal.state = {
+      ...modal.state,
+      securityGroup,
+      taskMonitor: { submit: jasmine.createSpy('submit').and.callFake((method: () => any) => method()) },
+    };
+    modal.setState = (updater: any) => {
+      const nextState = typeof updater === 'function' ? updater(modal.state, modal.props) : updater;
+      modal.state = { ...modal.state, ...nextState };
+    };
+    return modal;
+  }
+
+  it('preserves inferred source security group identity when initializing edit rules', () => {
+    const initialized = initializeAmazonSecurityGroupForModal(
+      { mode: 'edit', securityGroup: inferredSecurityGroup() } as any,
+      'fnord',
+    );
+
+    expect(initialized.securityGroupIngress).toEqual([
+      {
+        account: 'source-account',
+        accountId: 'source-account-id',
+        accountName: 'source-account-name',
+        endPort: 443,
+        existing: true,
+        id: 'sg-123456',
+        name: null,
+        startPort: 443,
+        type: 'tcp',
+        vpcId: 'vpc-source',
+      },
+    ]);
+  });
+
+  it('accepts existing source security group rules identified by either name or id', () => {
+    const securityGroup = initializeAmazonSecurityGroupForModal(
+      { mode: 'edit', securityGroup: inferredSecurityGroup() } as any,
+      'fnord',
+    );
+    const rule = securityGroup.securityGroupIngress[0];
+
+    expect(isAmazonSecurityGroupValid(securityGroup)).toBe(true);
+    expect(
+      isAmazonSecurityGroupValid({
+        ...securityGroup,
+        securityGroupIngress: [{ ...rule, id: undefined, name: 'named-source-group' }],
+      }),
+    ).toBe(true);
+  });
+
+  it('renders existing identity immutably, allows protocol and port edits, and submits the retained identity', () => {
+    spyOn(SecurityGroupWriter, 'upsertSecurityGroup').and.returnValue(Promise.resolve({} as any));
+    const securityGroup = initializeAmazonSecurityGroupForModal(
+      { mode: 'edit', securityGroup: inferredSecurityGroup() } as any,
+      'fnord',
+    );
+    const modal = buildModal(securityGroup);
+    const wrapper = shallow(<div>{modal.renderSecurityGroupRules()}</div>);
+    const inputs = wrapper.find('input');
+
+    expect(wrapper.text()).toContain('sg-123456');
+    expect(inputs.length).toBe(3);
+    expect(inputs.someWhere((input) => input.prop('value') === 'sg-123456')).toBe(false);
+
+    inputs.at(0).simulate('change', { target: { value: 'udp' } });
+    inputs.at(1).simulate('change', { target: { value: '8443' } });
+    inputs.at(2).simulate('change', { target: { value: '9443' } });
+    modal.submit();
+
+    const submittedRule = (SecurityGroupWriter.upsertSecurityGroup as jasmine.Spy).calls.mostRecent().args[0]
+      .securityGroupIngress[0];
+    expect(submittedRule).toEqual({
+      account: 'source-account',
+      accountId: 'source-account-id',
+      accountName: 'source-account-name',
+      endPort: 9443,
+      existing: true,
+      id: 'sg-123456',
+      name: null,
+      startPort: 8443,
+      type: 'udp',
+      vpcId: 'vpc-source',
+    });
+  });
+
+  it('submits cloned rules by their editable name without stale source identity', () => {
+    spyOn(SecurityGroupWriter, 'upsertSecurityGroup').and.returnValue(Promise.resolve({} as any));
+    const source = inferredSecurityGroup();
+    source.inboundRules[0].securityGroup.inferredName = false;
+    source.inboundRules[0].securityGroup.name = 'resolved-source-group';
+    const securityGroup = initializeAmazonSecurityGroupForModal(
+      { mode: 'clone', securityGroup: source } as any,
+      'fnord',
+    );
+    const modal = buildModal(securityGroup, 'clone');
+    const wrapper = shallow(<div>{modal.renderSecurityGroupRules()}</div>);
+    const nameInput = wrapper.find('input').at(0);
+
+    expect(nameInput.prop('value')).toBe('resolved-source-group');
+
+    nameInput.simulate('change', { target: { value: 'cloned-source-group' } });
+    modal.submit();
+
+    const submittedRule = (SecurityGroupWriter.upsertSecurityGroup as jasmine.Spy).calls.mostRecent().args[0]
+      .securityGroupIngress[0];
+    expect(submittedRule).toEqual({
+      endPort: 443,
+      name: 'cloned-source-group',
+      startPort: 443,
+      type: 'tcp',
+    });
+  });
+
+  it('requires an inferred source group to be replaced by name when cloning', () => {
+    const source = inferredSecurityGroup();
+    source.inboundRules[0].securityGroup.name = 'sg-123456';
+
+    const securityGroup = initializeAmazonSecurityGroupForModal(
+      { mode: 'clone', securityGroup: source } as any,
+      'fnord',
+    );
+
+    expect(securityGroup.securityGroupIngress[0].name).toBeNull();
+    expect(isAmazonSecurityGroupValid(securityGroup)).toBe(false);
+  });
+});