@spinnaker/amazon 0.11.1 → 0.12.3

package/src/loadBalancer/details/loadBalancerDetails.controller.spec.ts

@@ -1,7 +1,9 @@
-import { IControllerService, IRootScopeService, mock } from 'angular';
-import { StateService } from '@uirouter/core';
+import type { StateService } from '@uirouter/core';
+import type { IControllerService, IRootScopeService } from 'angular';
+import { mock } from 'angular';
 
-import { ApplicationModelBuilder, ISubnet } from '@spinnaker/core';
+import type { ISubnet } from '@spinnaker/core';
+import { ApplicationModelBuilder } from '@spinnaker/core';
 
 import { AWS_LOAD_BALANCER_DETAILS_CTRL, AwsLoadBalancerDetailsController } from './loadBalancerDetails.controller';
 

package/src/reactShims/aws.react.injector.ts

@@ -3,6 +3,7 @@ import IInjectorService = angular.auto.IInjectorService;
 import type { FunctionReader } from '@spinnaker/core';
 import { ReactInject } from '@spinnaker/core';
 import type { EvaluateCloudFormationChangeSetExecutionService } from '../pipeline/stages/deployCloudFormation/evaluateCloudFormationChangeSetExecution.service';
+import type { AwsServerGroupCommandBuilder } from '../serverGroup/configure/serverGroupCommandBuilder.service';
 
 import type { AwsServerGroupConfigurationService } from '../serverGroup/configure/serverGroupConfiguration.service';
 import type { AwsServerGroupTransformer } from '../serverGroup/serverGroup.transformer';
@@ -10,7 +11,7 @@ import type { AwsServerGroupTransformer } from '../serverGroup/serverGroup.trans
 // prettier-ignore
 export class AwsReactInject extends ReactInject {
   public get awsInstanceTypeService() { return this.$injector.get('awsInstanceTypeService') as any; }
-  public get awsServerGroupCommandBuilder() { return this.$injector.get('awsServerGroupCommandBuilder') as any; }
+  public get awsServerGroupCommandBuilder() { return this.$injector.get('awsServerGroupCommandBuilder') as AwsServerGroupCommandBuilder; }
   public get awsServerGroupConfigurationService() { return this.$injector.get('awsServerGroupConfigurationService') as AwsServerGroupConfigurationService; }
   public get awsServerGroupTransformer() { return this.$injector.get('awsServerGroupTransformer') as AwsServerGroupTransformer; }
 

package/src/search/{searchResultFormatter.js → searchResultFormatter.ts}

@@ -1,18 +1,19 @@
-'use strict';
-
 import { module } from 'angular';
 
+import type { ISecurityGroupSearchResult } from '@spinnaker/core';
+import type { ISearchResultFormatter } 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) {
+    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,
   };
 });

package/src/serverGroup/configure/AmazonImageSelectInput.spec.tsx

@@ -1,13 +1,16 @@
-import React from 'react';
-import { mockHttpClient } from 'core/api/mock/jasmine';
 import { mock } from 'angular';
-import { ShallowWrapper, ReactWrapper, shallow, mount } from 'enzyme';
+import type { ReactWrapper, ShallowWrapper } from 'enzyme';
+import { mount, shallow } from 'enzyme';
+import React from 'react';
 
-import { IAmazonImage } from '../../image';
-import { Application } from 'core/application';
-import { REACT_MODULE } from 'core/reactShims';
+import { Application } from '@spinnaker/core';
+import { REACT_MODULE } from '@spinnaker/core';
 
-import { AmazonImageSelectInput, IAmazonImageSelectorProps, IAmazonImageSelectorState } from './AmazonImageSelectInput';
+import type { IAmazonImageSelectorProps, IAmazonImageSelectorState } from './AmazonImageSelectInput';
+import { AmazonImageSelectInput } from './AmazonImageSelectInput';
+// eslint-disable-next-line @spinnaker/import-from-npm-not-relative
+import { mockHttpClient } from '../../../../core/src/api/mock/jasmine';
+import type { IAmazonImage } from '../../image';
 const application = new Application('testapp', null, []);
 const region = 'us-region-1';
 const credentials = 'prodaccount';

package/src/serverGroup/configure/serverGroupCommandBuilder.aws.service.spec.js

@@ -3,16 +3,24 @@
 import { AccountService, SubnetReader } from '@spinnaker/core';
 
 import { AWSProviderSettings } from '../../aws.settings';
+import {
+  createCustomMockLaunchTemplate,
+  mockLaunchTemplate,
+  mockLaunchTemplateData,
+  mockServerGroup,
+} from '@spinnaker/mocks';
 
 describe('Service: awsServerGroup', function () {
   beforeEach(window.module(require('./serverGroupCommandBuilder.service').name));
 
+  let instanceTypeService;
   beforeEach(
     window.inject(function (awsServerGroupCommandBuilder, _instanceTypeService_, _$q_, $rootScope) {
       this.service = awsServerGroupCommandBuilder;
       this.$q = _$q_;
       this.$scope = $rootScope;
-      spyOn(_instanceTypeService_, 'getCategoryForInstanceType').and.returnValue(_$q_.when('custom'));
+      instanceTypeService = _instanceTypeService_;
+      spyOn(instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(_$q_.when('custom'));
     }),
   );
 
@@ -30,6 +38,7 @@ describe('Service: awsServerGroup', function () {
           min: 1,
           max: 1,
         },
+        instanceType: 'm5.large',
       };
 
       AWSProviderSettings.defaults = {
@@ -77,6 +86,73 @@ describe('Service: awsServerGroup', function () {
       this.$scope.$digest();
       expect(command.viewState.usePreferredZones).toBe(false);
     });
+
+    describe('extracts instanceProfile from pipeline cluster correctly', function () {
+      const cluster = {
+        account: 'prod',
+        availabilityZones: {
+          'us-west-1': ['d', 'g'],
+        },
+        capacity: {
+          min: 1,
+          max: 1,
+        },
+        instanceType: 'm5.large',
+      };
+
+      const clusters = [
+        {
+          desc: 'single instance type',
+          cluster: {
+            ...cluster,
+            instanceType: 'r5.large',
+          },
+          expected: {
+            instanceTypes: ['r5.large'],
+            useSimpleInstanceTypeSelector: true,
+          },
+        },
+        {
+          desc: 'multiple instance types',
+          cluster: {
+            ...cluster,
+            spotAllocationStrategy: 'capacity-optimized',
+            launchTemplateOverridesForInstanceType: [
+              {
+                instanceType: 't3.nano',
+                weightedCapacity: '2',
+              },
+              {
+                instanceType: 't3.micro',
+                weightedCapacity: '4',
+              },
+            ],
+          },
+          expected: {
+            instanceTypes: ['t3.nano', 't3.micro'],
+            useSimpleInstanceTypeSelector: false,
+          },
+        },
+      ];
+
+      clusters.forEach((test) => {
+        it(`cluster with ${test.desc}`, function () {
+          let actualCommand = null;
+          this.service.buildServerGroupCommandFromPipeline({}, test.cluster).then(function (result) {
+            actualCommand = result;
+          });
+          this.$scope.$digest();
+
+          expect(instanceTypeService.getCategoryForMultipleInstanceTypes).toHaveBeenCalledWith(
+            'aws',
+            test.expected.instanceTypes,
+          );
+          expect(actualCommand.viewState.useSimpleInstanceTypeSelector).toBe(
+            test.expected.useSimpleInstanceTypeSelector,
+          );
+        });
+      });
+    });
   });
 
   describe('buildServerGroupCommandFromExisting', function () {
@@ -97,6 +173,7 @@ describe('Service: awsServerGroup', function () {
             { processName: 'AddToLoadBalancer' },
           ],
         },
+        launchTemplate: mockLaunchTemplate,
       };
       var command = null;
       this.service.buildServerGroupCommandFromExisting({}, serverGroup).then(function (result) {
@@ -114,6 +191,7 @@ describe('Service: awsServerGroup', function () {
           vpczoneIdentifier: '',
           suspendedProcesses: [],
         },
+        launchTemplate: mockLaunchTemplate,
       };
       var command = null;
       this.service.buildServerGroupCommandFromExisting({}, serverGroup, 'editPipeline').then(function (result) {
@@ -125,5 +203,228 @@ describe('Service: awsServerGroup', function () {
       expect(command.viewState.useSimpleCapacity).toBe(false);
       expect(command.useSourceCapacity).toBe(true);
     });
+
+    describe('extracts properties from server group correctly', function () {
+      const sgCommon = {
+        ...mockServerGroup,
+        asg: {
+          autoScalingGroupName: 'myasg-test-v000',
+          availabilityZones: [],
+          vpczoneIdentifier: '',
+          suspendedProcesses: [],
+          enabledMetrics: [],
+        },
+      };
+
+      const testLt = createCustomMockLaunchTemplate('test-lt', {
+        ...mockLaunchTemplateData,
+        instanceMarketOptions: {
+          spotOptions: {
+            maxPrice: '0.50',
+          },
+        },
+        networkInterfaces: [
+          {
+            deviceIndex: 0,
+            groups: ['my-sg'],
+            ipv6AddressCount: 1,
+            ipv6Addresses: [],
+            privateIpAddresses: [],
+          },
+        ],
+        keyName: 'test',
+        kernelId: 'kernal-abc',
+        ramDiskId: 'ramDisk-123',
+        userData: 'thisisfakeuserdata',
+        instanceType: 'm5.large',
+      });
+
+      const serverGroupsWithoutMip = [
+        {
+          desc: 'launchConfig',
+          sg: {
+            ...sgCommon,
+            launchConfig: {
+              instanceType: 'r5.large',
+              securityGroups: [],
+            },
+          },
+          expected: {
+            instanceType: 'r5.large',
+            launchTemplateOverridesForInstanceType: undefined,
+            instanceTypesParam: ['r5.large'],
+            useSimpleInstanceTypeSelector: true,
+          },
+        },
+        {
+          desc: 'launchTemplate',
+          sg: {
+            ...sgCommon,
+            launchTemplate: testLt,
+          },
+          expected: {
+            instanceType: 'm5.large',
+            launchTemplateOverridesForInstanceType: undefined,
+            instanceTypesParam: ['m5.large'],
+            useSimpleInstanceTypeSelector: true,
+            spotPrice: '0.50',
+            associateIPv6Address: true,
+            securityGroups: ['my-sg'],
+          },
+        },
+      ];
+
+      const mipCommon = {
+        instancesDistribution: {
+          onDemandAllocationStrategy: 'prioritized',
+          onDemandBaseCapacity: 1,
+          onDemandPercentageAboveBaseCapacity: 50,
+          spotAllocationStrategy: 'capacity-optimized',
+        },
+      };
+
+      const serverGroupsWithMip = [
+        {
+          desc: 'mixedInstancesPolicy without overrides',
+          sg: {
+            ...sgCommon,
+            mixedInstancesPolicy: {
+              instancesDistribution: {
+                onDemandAllocationStrategy: 'prioritized',
+                onDemandBaseCapacity: 1,
+                onDemandPercentageAboveBaseCapacity: 50,
+                spotAllocationStrategy: 'capacity-optimized',
+                spotMaxPrice: '1.5',
+              },
+              allowedInstanceTypes: ['m5.large'],
+              launchTemplates: [testLt],
+            },
+          },
+          expected: {
+            instanceType: 'm5.large',
+            launchTemplateOverridesForInstanceType: undefined,
+            instanceTypesParam: ['m5.large'],
+            useSimpleInstanceTypeSelector: false,
+            spotPrice: '1.5',
+            associateIPv6Address: true,
+            securityGroups: ['my-sg'],
+          },
+        },
+        {
+          desc: 'mixedInstancesPolicy with overrides and no priority',
+          sg: {
+            ...sgCommon,
+            mixedInstancesPolicy: {
+              ...mipCommon,
+              launchTemplates: [mockLaunchTemplate],
+              allowedInstanceTypes: ['t3.nano', 'm5.large'],
+              launchTemplateOverridesForInstanceType: [
+                { instanceType: 't3.nano', weightedCapacity: '2' },
+                { instanceType: 'm5.large', weightedCapacity: '4' },
+              ],
+            },
+          },
+          expected: {
+            instanceType: undefined,
+            launchTemplateOverridesForInstanceType: [
+              { instanceType: 't3.nano', priority: 1, weightedCapacity: '2' },
+              { instanceType: 'm5.large', priority: 2, weightedCapacity: '4' },
+            ],
+            instanceTypesParam: ['t3.nano', 'm5.large'],
+            useSimpleInstanceTypeSelector: false,
+          },
+        },
+        {
+          desc: 'mixedInstancesPolicy with overrides and all instance types have priority',
+          sg: {
+            ...sgCommon,
+            mixedInstancesPolicy: {
+              ...mipCommon,
+              launchTemplates: [mockLaunchTemplate],
+              allowedInstanceTypes: ['t3.nano', 'm5.large'],
+              launchTemplateOverridesForInstanceType: [
+                { instanceType: 't3.nano', weightedCapacity: '2', priority: 2 },
+                { instanceType: 'm5.large', weightedCapacity: '4', priority: 1 },
+              ],
+            },
+          },
+          expected: {
+            instanceType: undefined,
+            launchTemplateOverridesForInstanceType: [
+              ,
+              { instanceType: 'm5.large', weightedCapacity: '4', priority: 1 },
+              { instanceType: 't3.nano', weightedCapacity: '2', priority: 2 },
+            ],
+            instanceTypesParam: ['t3.nano', 'm5.large'],
+            useSimpleInstanceTypeSelector: false,
+          },
+        },
+        {
+          desc: 'mixedInstancesPolicy with overrides and some instance types have priority',
+          sg: {
+            ...sgCommon,
+            mixedInstancesPolicy: {
+              ...mipCommon,
+              launchTemplates: [mockLaunchTemplate],
+              allowedInstanceTypes: ['t3.nano', 't3.micro', 't2.nano', 't2.micro'],
+              launchTemplateOverridesForInstanceType: [
+                { instanceType: 't3.nano' },
+                { instanceType: 't3.micro', priority: 2 },
+                { instanceType: 't2.nano' },
+                { instanceType: 't2.micro', priority: 1 },
+              ],
+            },
+          },
+          expected: {
+            instanceType: undefined,
+            launchTemplateOverridesForInstanceType: [
+              { instanceType: 't2.micro', priority: 1 },
+              { instanceType: 't3.micro', priority: 2 },
+              { instanceType: 't3.nano', priority: 3 },
+              { instanceType: 't2.nano', priority: 4 },
+            ],
+            instanceTypesParam: ['t3.nano', 't3.micro', 't2.nano', 't2.micro'],
+            useSimpleInstanceTypeSelector: false,
+          },
+        },
+      ];
+
+      [...serverGroupsWithoutMip, ...serverGroupsWithMip].forEach((test) => {
+        it(`extracts instanceProfile, instanceType and useSimpleInstanceTypeSelector from server group with ${test.desc} correctly`, function () {
+          let actualCommand = null;
+          this.service.buildServerGroupCommandFromExisting({}, test.sg, 'clone').then(function (result) {
+            actualCommand = result;
+          });
+          this.$scope.$digest();
+
+          expect(instanceTypeService.getCategoryForMultipleInstanceTypes).toHaveBeenCalledWith(
+            'aws',
+            test.expected.instanceTypesParam,
+          );
+          expect(actualCommand.instanceType).toBe(test.expected.instanceType);
+          expect(actualCommand.viewState.useSimpleInstanceTypeSelector).toBe(
+            test.expected.useSimpleInstanceTypeSelector,
+          );
+          test.expected.spotPrice && expect(actualCommand.spotPrice).toBe(test.expected.spotPrice);
+        });
+      });
+
+      serverGroupsWithMip.forEach((test) => {
+        it(`extracts launchTemplateOverridesForInstanceType and sets explicit priority correctly for server group with ${test.desc}`, function () {
+          let actualCommand = null;
+          this.service.buildServerGroupCommandFromExisting({}, test.sg, 'clone').then(function (result) {
+            actualCommand = result;
+          });
+          this.$scope.$digest();
+
+          expect(
+            _.isEqual(
+              actualCommand.launchTemplateOverridesForInstanceType,
+              test.expected.launchTemplateOverridesForInstanceType,
+            ).toBeTruthy,
+          );
+        });
+      });
+    });
   });
 });